TLD Parser Dart SDK #

A Dart SDK for parsing and resolving AllDomains ANS Protocol domains on Solana. Supports any TLD including .skr, .abc, .poor, .bonk, and more.

Key Insight: ANS vs SNS #

The existing SNS Dart packages only support .sol domains. This SDK is for all other TLDs.

Installation #

Add to your pubspec.yaml:

dependencies:
  tld_parser: ^0.1.0

Quick Start #

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

void main() async {
  // Initialize
  final rpcClient = RpcClient('https://api.mainnet-beta.solana.com');
  final parser = TldParser(rpcClient);

  // Resolve a domain to its owner
  final owner = await parser.getOwnerFromDomainTld('miester.abc');
  print('Owner: ${owner?.toBase58()}');

  // Get a user's main domain (reverse lookup)
  final mainDomain = await parser.tryGetMainDomain(owner!);
  print('Main domain: ${mainDomain?.fullDomain}');

  // Fetch domain records
  final twitter = await parser.getRecord('miester.abc', Record.twitter);
  print('Twitter: $twitter');

  // Get all domains owned by a user
  final domains = await parser.getAllUserDomainsFromTld(owner, 'abc');
  print('User owns ${domains.length} .abc domains');
}

Features #

Domain Resolution #

// Get owner of any domain
final owner = await parser.getOwnerFromDomainTld('miester.abc');

// Works with subdomains too
final subOwner = await parser.getOwnerFromDomainTld('vault.miester.abc');

// Get the full name record with metadata
final record = await parser.getNameRecordFromDomainTld('miester.abc');
print('Created: ${record?.createdAtDateTime}');
print('Expires: ${record?.expiresAtDateTime}');
print('Is valid: ${record?.isValid}');

Reverse Lookup #

// Get a user's main domain
final mainDomain = await parser.getMainDomain(userPubkey);
print('${mainDomain.fullDomain}'); // e.g., 'miester.abc'

// Try without throwing (returns null if not set)
final maybe = await parser.tryGetMainDomain(userPubkey);

Domain Listing #

// Get all domains owned by a user (all TLDs)
final allDomains = await parser.getAllUserDomains(userPubkey);

// Get domains in a specific TLD
final abcDomains = await parser.getAllUserDomainsFromTld(userPubkey, 'abc');

// Get parsed domain names (with reverse lookups)
final parsed = await parser.getParsedAllUserDomainsFromTld(userPubkey, 'abc');
for (final d in parsed) {
  print('${d.domain} -> ${d.nameAccount.toBase58()}');
}

Record Fetching #

// Get a specific record
final twitter = await parser.getRecord('miester.abc', Record.twitter);
final email = await parser.getRecord('miester.abc', Record.email);

// Get multiple records at once (efficient batching)
final records = await parser.getRecords('miester.abc', [
  Record.twitter,
  Record.discord,
  Record.github,
  Record.email,
]);

// Get all available records
final allRecords = await parser.getAllRecords('miester.abc');

Available Records #

The SDK supports the following record types:

Content/Storage:

• Record.ipfs - IPFS content hash
• Record.arwv - Arweave content hash
• Record.url - URL link
• Record.shdw - Shadow Drive

Crypto Addresses:

• Record.sol, Record.eth, Record.btc
• Record.aptos, Record.near, Record.sui
• Record.base, Record.stacks
• Record.ltc, Record.doge, Record.point, Record.lattica

Social:

• Record.twitter, Record.discord
• Record.github, Record.reddit, Record.telegram

Profile:

• Record.pic - Profile picture
• Record.email - Email address

NFT-Wrapped Domains #

The SDK automatically handles NFT-wrapped domains. When a domain is wrapped as an NFT, the SDK resolves through the NFT record to find the actual token holder:

// This works whether the domain is wrapped or not
final owner = await parser.getOwnerFromDomainTld('miester.abc');

Domain Key Derivation #

For advanced use cases, you can derive domain keys directly:

// Derive a domain key
final domainKey = await getDomainKey('miester.abc');
print('Domain account: ${domainKey.pubkey.toBase58()}');

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

// Derive a record key
final recordKey = await getDomainKey('Twitter.miester.abc', record: true);

Error Handling #

try {
  final owner = await parser.getOwnerFromDomainTld('nonexistent.abc');
} on DomainNotFoundException catch (e) {
  print('Domain not found: ${e.domain}');
} on InvalidDomainFormatException catch (e) {
  print('Invalid format: ${e.message}');
} on TldParserException catch (e) {
  print('Parser error: ${e.message}');
}

Architecture #

tld_parser_dart/
├── lib/
│   ├── tld_parser.dart           # Main export
│   └── src/
│       ├── constants.dart        # Program IDs, prefixes
│       ├── utils.dart            # Hashing, seeds
│       ├── pda.dart              # PDA derivation
│       ├── name_record_handler.dart  # getDomainKey
│       ├── tld_parser.dart       # Main TldParser class
│       ├── exceptions.dart       # Exception types
│       ├── state/
│       │   ├── name_record_header.dart
│       │   ├── main_domain.dart
│       │   └── nft_record.dart
│       └── types/
│           ├── records.dart
│           ├── domain_key_result.dart
│           └── tag.dart
├── test/
│   └── ...
└── example/
    └── example.dart

Performance #

The SDK is optimized for performance:

• Batched RPC calls: Multiple accounts are fetched in single calls
• Chunking: Large requests are automatically chunked to respect RPC limits
• Efficient PDAs: Program addresses are derived using optimized algorithms

Contributing #

See CONTRIBUTING.md for guidelines.

License #

MIT License - see LICENSE for details.

References #

• AllDomains Documentation
• ANS Program
• TypeScript SDK
• Rust SDK