@unicitylabs/sphere-sdk 0.1.3 → 0.1.5

package/dist/index.d.ts

@@ -17,8 +17,8 @@ import { MintTransactionData } from '@unicitylabs/state-transition-sdk/lib/trans
 import { MintCommitment } from '@unicitylabs/state-transition-sdk/lib/transaction/MintCommitment';
 import { TransferTransaction } from '@unicitylabs/state-transition-sdk/lib/transaction/TransferTransaction';
 import { SigningService } from '@unicitylabs/state-transition-sdk/lib/sign/SigningService';
-import { ProxyAddress } from '@unicitylabs/state-transition-sdk/lib/address/ProxyAddress';
 import { AddressScheme } from '@unicitylabs/state-transition-sdk/lib/address/AddressScheme';
+import { hashNametag } from '@unicitylabs/nostr-js-sdk';
 
 /**
  * Cryptographic utilities for SDK2
@@ -407,11 +407,12 @@ interface BaseProvider extends ProviderMetadata {
     getStatus(): ProviderStatus;
 }
 interface Identity {
-    readonly publicKey: string;
+    /** 33-byte compressed secp256k1 public key (for L3 chain) */
+    readonly chainPubkey: string;
     /** L1 address (alpha1...) */
-    readonly address: string;
-    /** L3 predicate address (DIRECT://...) */
-    readonly predicateAddress?: string;
+    readonly l1Address: string;
+    /** L3 DIRECT address (DIRECT://...) */
+    readonly directAddress?: string;
     readonly ipnsName?: string;
     readonly nametag?: string;
 }
@@ -429,6 +430,8 @@ interface Token {
     readonly coinId: string;
     readonly symbol: string;
     readonly name: string;
+    readonly decimals: number;
+    readonly iconUrl?: string;
     readonly amount: string;
     status: TokenStatus;
     readonly createdAt: number;
@@ -601,7 +604,7 @@ interface BroadcastMessage {
     readonly timestamp: number;
     readonly tags?: string[];
 }
-type SphereEventType = 'transfer:incoming' | 'transfer:confirmed' | 'transfer:failed' | 'payment_request:incoming' | 'payment_request:accepted' | 'payment_request:rejected' | 'payment_request:paid' | 'payment_request:response' | 'message:dm' | 'message:broadcast' | 'sync:started' | 'sync:completed' | 'sync:provider' | 'sync:error' | 'connection:changed' | 'nametag:registered' | 'identity:changed';
+type SphereEventType = 'transfer:incoming' | 'transfer:confirmed' | 'transfer:failed' | 'payment_request:incoming' | 'payment_request:accepted' | 'payment_request:rejected' | 'payment_request:paid' | 'payment_request:response' | 'message:dm' | 'message:broadcast' | 'sync:started' | 'sync:completed' | 'sync:provider' | 'sync:error' | 'connection:changed' | 'nametag:registered' | 'nametag:recovered' | 'identity:changed';
 interface SphereEventMap {
     'transfer:incoming': IncomingTransfer;
     'transfer:confirmed': TransferResult;
@@ -639,10 +642,13 @@ interface SphereEventMap {
         nametag: string;
         addressIndex: number;
     };
+    'nametag:recovered': {
+        nametag: string;
+    };
     'identity:changed': {
-        address: string;
-        predicateAddress?: string;
-        publicKey: string;
+        l1Address: string;
+        directAddress?: string;
+        chainPubkey: string;
         nametag?: string;
         addressIndex: number;
     };
@@ -748,6 +754,253 @@ interface WalletJSONExportOptions$1 {
     addressCount?: number;
 }
 
+/**
+ * Transport Provider Interface
+ * Platform-independent P2P messaging abstraction
+ */
+
+/**
+ * P2P messaging transport provider
+ */
+interface TransportProvider extends BaseProvider {
+    /**
+     * Set identity for signing/encryption
+     */
+    setIdentity(identity: FullIdentity): void;
+    /**
+     * Send encrypted direct message
+     * @param recipientTransportPubkey - Transport-specific pubkey for messaging
+     * @returns Event ID
+     */
+    sendMessage(recipientTransportPubkey: string, content: string): Promise<string>;
+    /**
+     * Subscribe to incoming direct messages
+     * @returns Unsubscribe function
+     */
+    onMessage(handler: MessageHandler): () => void;
+    /**
+     * Send token transfer payload
+     * @param recipientTransportPubkey - Transport-specific pubkey for messaging
+     * @returns Event ID
+     */
+    sendTokenTransfer(recipientTransportPubkey: string, payload: TokenTransferPayload): Promise<string>;
+    /**
+     * Subscribe to incoming token transfers
+     * @returns Unsubscribe function
+     */
+    onTokenTransfer(handler: TokenTransferHandler): () => void;
+    /**
+     * Resolve nametag to public key
+     */
+    resolveNametag?(nametag: string): Promise<string | null>;
+    /**
+     * Resolve nametag to full address information
+     * Returns transportPubkey, chainPubkey, l1Address, directAddress, proxyAddress
+     */
+    resolveNametagInfo?(nametag: string): Promise<NametagInfo | null>;
+    /**
+     * Recover nametag for current identity by decrypting stored encrypted nametag
+     * Used after wallet import to recover associated nametag
+     * @returns Decrypted nametag or null if none found
+     */
+    recoverNametag?(): Promise<string | null>;
+    /**
+     * Register a nametag for this identity
+     * @param nametag - Nametag to register
+     * @param chainPubkey - 33-byte compressed secp256k1 public key (for L1/L3)
+     * @param directAddress - L3 DIRECT address (DIRECT://...)
+     * @returns true if successful, false if already taken
+     */
+    registerNametag?(nametag: string, chainPubkey: string, directAddress: string): Promise<boolean>;
+    /**
+     * Publish nametag binding
+     */
+    publishNametag?(nametag: string, address: string): Promise<void>;
+    /**
+     * Subscribe to broadcast messages (global/channel)
+     */
+    subscribeToBroadcast?(tags: string[], handler: BroadcastHandler): () => void;
+    /**
+     * Publish broadcast message
+     */
+    publishBroadcast?(content: string, tags?: string[]): Promise<string>;
+    /**
+     * Send payment request to a recipient
+     * @param recipientTransportPubkey - Transport-specific pubkey for messaging
+     * @returns Event ID
+     */
+    sendPaymentRequest?(recipientTransportPubkey: string, request: PaymentRequestPayload): Promise<string>;
+    /**
+     * Subscribe to incoming payment requests
+     * @returns Unsubscribe function
+     */
+    onPaymentRequest?(handler: PaymentRequestHandler): () => void;
+    /**
+     * Send response to a payment request
+     * @param recipientTransportPubkey - Transport-specific pubkey for messaging
+     * @returns Event ID
+     */
+    sendPaymentRequestResponse?(recipientTransportPubkey: string, response: PaymentRequestResponsePayload): Promise<string>;
+    /**
+     * Subscribe to incoming payment request responses
+     * @returns Unsubscribe function
+     */
+    onPaymentRequestResponse?(handler: PaymentRequestResponseHandler): () => void;
+    /**
+     * Get list of configured relay URLs
+     */
+    getRelays?(): string[];
+    /**
+     * Get list of currently connected relay URLs
+     */
+    getConnectedRelays?(): string[];
+    /**
+     * Add a relay dynamically
+     * @returns true if added successfully
+     */
+    addRelay?(relayUrl: string): Promise<boolean>;
+    /**
+     * Remove a relay dynamically
+     * @returns true if removed successfully
+     */
+    removeRelay?(relayUrl: string): Promise<boolean>;
+    /**
+     * Check if a relay is configured
+     */
+    hasRelay?(relayUrl: string): boolean;
+    /**
+     * Check if a relay is currently connected
+     */
+    isRelayConnected?(relayUrl: string): boolean;
+}
+interface IncomingMessage {
+    id: string;
+    /** Transport-specific pubkey of sender */
+    senderTransportPubkey: string;
+    /** Sender's nametag (if known from NIP-17 unwrap) */
+    senderNametag?: string;
+    content: string;
+    timestamp: number;
+    encrypted: boolean;
+}
+type MessageHandler = (message: IncomingMessage) => void;
+interface TokenTransferPayload {
+    /** Serialized token data */
+    token: string;
+    /** Inclusion proof */
+    proof: unknown;
+    /** Optional memo */
+    memo?: string;
+    /** Sender info */
+    sender?: {
+        /** Transport-specific pubkey */
+        transportPubkey: string;
+        nametag?: string;
+    };
+}
+interface IncomingTokenTransfer {
+    id: string;
+    /** Transport-specific pubkey of sender */
+    senderTransportPubkey: string;
+    payload: TokenTransferPayload;
+    timestamp: number;
+}
+type TokenTransferHandler = (transfer: IncomingTokenTransfer) => void;
+interface PaymentRequestPayload {
+    /** Amount requested (in smallest units) */
+    amount: string | bigint;
+    /** Coin/token type ID */
+    coinId: string;
+    /** Message/memo for recipient */
+    message?: string;
+    /** Recipient's nametag (who should pay) */
+    recipientNametag?: string;
+    /** Custom metadata */
+    metadata?: Record<string, unknown>;
+}
+interface IncomingPaymentRequest {
+    /** Event ID */
+    id: string;
+    /** Transport-specific pubkey of sender */
+    senderTransportPubkey: string;
+    /** Parsed request data */
+    request: {
+        requestId: string;
+        amount: string;
+        coinId: string;
+        message?: string;
+        recipientNametag?: string;
+        metadata?: Record<string, unknown>;
+    };
+    /** Timestamp */
+    timestamp: number;
+}
+type PaymentRequestHandler = (request: IncomingPaymentRequest) => void;
+type PaymentRequestResponseType = 'accepted' | 'rejected' | 'paid';
+interface PaymentRequestResponsePayload {
+    /** Original request ID */
+    requestId: string;
+    /** Response type */
+    responseType: PaymentRequestResponseType;
+    /** Optional message */
+    message?: string;
+    /** Transfer ID (if paid) */
+    transferId?: string;
+}
+interface IncomingPaymentRequestResponse {
+    /** Event ID */
+    id: string;
+    /** Transport-specific pubkey of responder */
+    responderTransportPubkey: string;
+    /** Parsed response data */
+    response: {
+        requestId: string;
+        responseType: PaymentRequestResponseType;
+        message?: string;
+        transferId?: string;
+    };
+    /** Timestamp */
+    timestamp: number;
+}
+type PaymentRequestResponseHandler = (response: IncomingPaymentRequestResponse) => void;
+interface IncomingBroadcast {
+    id: string;
+    /** Transport-specific pubkey of author */
+    authorTransportPubkey: string;
+    content: string;
+    tags: string[];
+    timestamp: number;
+}
+type BroadcastHandler = (broadcast: IncomingBroadcast) => void;
+type TransportEventType = 'transport:connected' | 'transport:disconnected' | 'transport:reconnecting' | 'transport:error' | 'transport:relay_added' | 'transport:relay_removed' | 'message:received' | 'message:sent' | 'transfer:received' | 'transfer:sent';
+interface TransportEvent {
+    type: TransportEventType;
+    timestamp: number;
+    data?: unknown;
+    error?: string;
+}
+type TransportEventCallback = (event: TransportEvent) => void;
+/**
+ * Full nametag address information
+ * Used for resolving nametag to all address formats
+ */
+interface NametagInfo {
+    /** Nametag name (without @) */
+    nametag: string;
+    /** Transport-specific pubkey (for messaging/encryption) */
+    transportPubkey: string;
+    /** 33-byte compressed secp256k1 public key (for L3 chain) */
+    chainPubkey: string;
+    /** L1 address (alpha1...) */
+    l1Address: string;
+    /** L3 DIRECT address (DIRECT://...) */
+    directAddress: string;
+    /** L3 PROXY address derived from nametag hash (PROXY:...) */
+    proxyAddress: string;
+    /** Event timestamp */
+    timestamp: number;
+}
+
 /**
  * L1 Payments Sub-Module
  *
@@ -817,6 +1070,8 @@ interface L1PaymentsModuleDependencies {
     identity: FullIdentity;
     chainCode?: string;
     addresses?: string[];
+    /** Transport provider for nametag resolution (optional) */
+    transport?: TransportProvider;
 }
 /**
  * L1 Payments Module - Full Implementation
@@ -831,9 +1086,23 @@ declare class L1PaymentsModule$1 {
     private _chainCode?;
     private _addresses;
     private _wallet?;
+    private _transport?;
     constructor(config?: L1PaymentsModuleConfig);
     initialize(deps: L1PaymentsModuleDependencies): Promise<void>;
     destroy(): void;
+    /**
+     * Check if a string looks like an L1 address (alpha1... or alphat1...)
+     */
+    private isL1Address;
+    /**
+     * Resolve recipient to L1 address
+     * Supports: L1 address (alpha1...), nametag (with or without @)
+     */
+    private resolveL1Address;
+    /**
+     * Resolve nametag to L1 address using transport provider
+     */
+    private resolveNametagToL1Address;
     send(request: L1SendRequest): Promise<L1SendResult>;
     getBalance(): Promise<L1Balance>;
     getUtxos(): Promise<L1Utxo[]>;
@@ -1043,209 +1312,6 @@ interface TxfInvalidEntry {
     detectedAt: number;
 }
 
-/**
- * Transport Provider Interface
- * Platform-independent P2P messaging abstraction
- */
-
-/**
- * P2P messaging transport provider
- */
-interface TransportProvider extends BaseProvider {
-    /**
-     * Set identity for signing/encryption
-     */
-    setIdentity(identity: FullIdentity): void;
-    /**
-     * Send encrypted direct message
-     * @returns Event ID
-     */
-    sendMessage(recipientPubkey: string, content: string): Promise<string>;
-    /**
-     * Subscribe to incoming direct messages
-     * @returns Unsubscribe function
-     */
-    onMessage(handler: MessageHandler): () => void;
-    /**
-     * Send token transfer payload
-     * @returns Event ID
-     */
-    sendTokenTransfer(recipientPubkey: string, payload: TokenTransferPayload): Promise<string>;
-    /**
-     * Subscribe to incoming token transfers
-     * @returns Unsubscribe function
-     */
-    onTokenTransfer(handler: TokenTransferHandler): () => void;
-    /**
-     * Resolve nametag to public key
-     */
-    resolveNametag?(nametag: string): Promise<string | null>;
-    /**
-     * Register a nametag for this identity
-     * @returns true if successful, false if already taken
-     */
-    registerNametag?(nametag: string, publicKey: string): Promise<boolean>;
-    /**
-     * Publish nametag binding
-     */
-    publishNametag?(nametag: string, address: string): Promise<void>;
-    /**
-     * Subscribe to broadcast messages (global/channel)
-     */
-    subscribeToBroadcast?(tags: string[], handler: BroadcastHandler): () => void;
-    /**
-     * Publish broadcast message
-     */
-    publishBroadcast?(content: string, tags?: string[]): Promise<string>;
-    /**
-     * Send payment request to a recipient
-     * @returns Event ID
-     */
-    sendPaymentRequest?(recipientPubkey: string, request: PaymentRequestPayload): Promise<string>;
-    /**
-     * Subscribe to incoming payment requests
-     * @returns Unsubscribe function
-     */
-    onPaymentRequest?(handler: PaymentRequestHandler): () => void;
-    /**
-     * Send response to a payment request
-     * @returns Event ID
-     */
-    sendPaymentRequestResponse?(recipientPubkey: string, response: PaymentRequestResponsePayload): Promise<string>;
-    /**
-     * Subscribe to incoming payment request responses
-     * @returns Unsubscribe function
-     */
-    onPaymentRequestResponse?(handler: PaymentRequestResponseHandler): () => void;
-    /**
-     * Get list of configured relay URLs
-     */
-    getRelays?(): string[];
-    /**
-     * Get list of currently connected relay URLs
-     */
-    getConnectedRelays?(): string[];
-    /**
-     * Add a relay dynamically
-     * @returns true if added successfully
-     */
-    addRelay?(relayUrl: string): Promise<boolean>;
-    /**
-     * Remove a relay dynamically
-     * @returns true if removed successfully
-     */
-    removeRelay?(relayUrl: string): Promise<boolean>;
-    /**
-     * Check if a relay is configured
-     */
-    hasRelay?(relayUrl: string): boolean;
-    /**
-     * Check if a relay is currently connected
-     */
-    isRelayConnected?(relayUrl: string): boolean;
-}
-interface IncomingMessage {
-    id: string;
-    senderPubkey: string;
-    content: string;
-    timestamp: number;
-    encrypted: boolean;
-}
-type MessageHandler = (message: IncomingMessage) => void;
-interface TokenTransferPayload {
-    /** Serialized token data */
-    token: string;
-    /** Inclusion proof */
-    proof: unknown;
-    /** Optional memo */
-    memo?: string;
-    /** Sender info */
-    sender?: {
-        pubkey: string;
-        nametag?: string;
-    };
-}
-interface IncomingTokenTransfer {
-    id: string;
-    senderPubkey: string;
-    payload: TokenTransferPayload;
-    timestamp: number;
-}
-type TokenTransferHandler = (transfer: IncomingTokenTransfer) => void;
-interface PaymentRequestPayload {
-    /** Amount requested (in smallest units) */
-    amount: string | bigint;
-    /** Coin/token type ID */
-    coinId: string;
-    /** Message/memo for recipient */
-    message?: string;
-    /** Recipient's nametag (who should pay) */
-    recipientNametag?: string;
-    /** Custom metadata */
-    metadata?: Record<string, unknown>;
-}
-interface IncomingPaymentRequest {
-    /** Event ID */
-    id: string;
-    /** Sender's public key */
-    senderPubkey: string;
-    /** Parsed request data */
-    request: {
-        requestId: string;
-        amount: string;
-        coinId: string;
-        message?: string;
-        recipientNametag?: string;
-        metadata?: Record<string, unknown>;
-    };
-    /** Timestamp */
-    timestamp: number;
-}
-type PaymentRequestHandler = (request: IncomingPaymentRequest) => void;
-type PaymentRequestResponseType = 'accepted' | 'rejected' | 'paid';
-interface PaymentRequestResponsePayload {
-    /** Original request ID */
-    requestId: string;
-    /** Response type */
-    responseType: PaymentRequestResponseType;
-    /** Optional message */
-    message?: string;
-    /** Transfer ID (if paid) */
-    transferId?: string;
-}
-interface IncomingPaymentRequestResponse {
-    /** Event ID */
-    id: string;
-    /** Responder's public key */
-    responderPubkey: string;
-    /** Parsed response data */
-    response: {
-        requestId: string;
-        responseType: PaymentRequestResponseType;
-        message?: string;
-        transferId?: string;
-    };
-    /** Timestamp */
-    timestamp: number;
-}
-type PaymentRequestResponseHandler = (response: IncomingPaymentRequestResponse) => void;
-interface IncomingBroadcast {
-    id: string;
-    authorPubkey: string;
-    content: string;
-    tags: string[];
-    timestamp: number;
-}
-type BroadcastHandler = (broadcast: IncomingBroadcast) => void;
-type TransportEventType = 'transport:connected' | 'transport:disconnected' | 'transport:reconnecting' | 'transport:error' | 'transport:relay_added' | 'transport:relay_removed' | 'message:received' | 'message:sent' | 'transfer:received' | 'transfer:sent';
-interface TransportEvent {
-    type: TransportEventType;
-    timestamp: number;
-    data?: unknown;
-    error?: string;
-}
-type TransportEventCallback = (event: TransportEvent) => void;
-
 /**
  * Oracle Provider Interface
  * Platform-independent Unicity oracle abstraction
@@ -1491,6 +1557,14 @@ declare class PaymentsModule$1 {
      * Get coin name from coinId
      */
     private getCoinName;
+    /**
+     * Get coin decimals from coinId
+     */
+    private getCoinDecimals;
+    /**
+     * Get coin icon URL from coinId
+     */
+    private getCoinIconUrl;
     /**
      * Send a payment request to someone
      * @param recipientPubkeyOrNametag - Recipient's pubkey or @nametag
@@ -1743,6 +1817,15 @@ declare class PaymentsModule$1 {
      * Get pending transfers
      */
     getPendingTransfers(): TransferResult[];
+    /**
+     * Detect if a string is an L3 address (not a nametag)
+     * Returns true for: hex pubkeys (64+ chars), PROXY:, DIRECT: prefixed addresses
+     */
+    private isL3Address;
+    /**
+     * Resolve recipient to Nostr pubkey for messaging
+     * Supports: nametag (with or without @), hex pubkey
+     */
     private resolveRecipient;
     /**
      * Create SDK TransferCommitment for a token transfer
@@ -1753,7 +1836,17 @@ declare class PaymentsModule$1 {
      */
     private createSigningService;
     /**
-     * Resolve recipient to IAddress
+     * Create DirectAddress from a public key using UnmaskedPredicateReference
+     */
+    private createDirectAddressFromPubkey;
+    /**
+     * Resolve nametag to 33-byte compressed public key using resolveNametagInfo
+     * Returns null if nametag not found or publicKey not available
+     */
+    private resolveNametagToPublicKey;
+    /**
+     * Resolve recipient to IAddress for L3 transfers
+     * Supports: nametag (with or without @), PROXY:, DIRECT:, hex pubkey
      */
     private resolveRecipientAddress;
     private handleIncomingTransfer;
@@ -1863,49 +1956,39 @@ declare function createCommunicationsModule$1(config?: CommunicationsModuleConfi
  * Default configuration values and storage keys
  */
 /** Default prefix for all storage keys */
-declare const STORAGE_PREFIX$1: "sphere_";
-/** Storage keys for wallet data */
-declare const STORAGE_KEYS$1: {
+declare const STORAGE_PREFIX: "sphere_";
+/** @deprecated Use STORAGE_KEYS_GLOBAL and STORAGE_KEYS_ADDRESS instead */
+declare const STORAGE_KEYS: {
+    /** Pending transfers for this address */
+    readonly PENDING_TRANSFERS: "pending_transfers";
+    /** Transfer outbox for this address */
+    readonly OUTBOX: "outbox";
+    /** Conversations for this address */
+    readonly CONVERSATIONS: "conversations";
+    /** Messages for this address */
+    readonly MESSAGES: "messages";
+    /** Transaction history for this address */
+    readonly TRANSACTION_HISTORY: "transaction_history";
     /** Encrypted BIP39 mnemonic */
-    readonly MNEMONIC: "sphere_mnemonic";
+    readonly MNEMONIC: "mnemonic";
     /** Encrypted master private key */
-    readonly MASTER_KEY: "sphere_master_key";
+    readonly MASTER_KEY: "master_key";
     /** BIP32 chain code */
-    readonly CHAIN_CODE: "sphere_chain_code";
+    readonly CHAIN_CODE: "chain_code";
     /** HD derivation path (full path like m/44'/0'/0'/0/0) */
-    readonly DERIVATION_PATH: "sphere_derivation_path";
+    readonly DERIVATION_PATH: "derivation_path";
     /** Base derivation path (like m/44'/0'/0' without chain/index) */
-    readonly BASE_PATH: "sphere_base_path";
+    readonly BASE_PATH: "base_path";
     /** Derivation mode: bip32, wif_hmac, legacy_hmac */
-    readonly DERIVATION_MODE: "sphere_derivation_mode";
+    readonly DERIVATION_MODE: "derivation_mode";
     /** Wallet source: mnemonic, file, unknown */
-    readonly WALLET_SOURCE: "sphere_wallet_source";
+    readonly WALLET_SOURCE: "wallet_source";
     /** Wallet existence flag */
-    readonly WALLET_EXISTS: "sphere_wallet_exists";
-    /** Registered nametag (legacy - single address) */
-    readonly NAMETAG: "sphere_nametag";
+    readonly WALLET_EXISTS: "wallet_exists";
     /** Current active address index */
-    readonly CURRENT_ADDRESS_INDEX: "sphere_current_address_index";
-    /** Address nametags map (JSON: { "0": "alice", "1": "bob" }) */
-    readonly ADDRESS_NAMETAGS: "sphere_address_nametags";
-    /** Token data */
-    readonly TOKENS: "sphere_tokens";
-    /** Pending transfers */
-    readonly PENDING_TRANSFERS: "sphere_pending_transfers";
-    /** Transfer outbox */
-    readonly OUTBOX: "sphere_outbox";
-    /** Conversations */
-    readonly CONVERSATIONS: "sphere_conversations";
-    /** Messages */
-    readonly MESSAGES: "sphere_messages";
-    /** Transaction history */
-    readonly TRANSACTION_HISTORY: "sphere_transaction_history";
-    /** Archived tokens (spent token history) */
-    readonly ARCHIVED_TOKENS: "sphere_archived_tokens";
-    /** Tombstones (records of deleted/spent tokens) */
-    readonly TOMBSTONES: "sphere_tombstones";
-    /** Forked tokens (alternative histories) */
-    readonly FORKED_TOKENS: "sphere_forked_tokens";
+    readonly CURRENT_ADDRESS_INDEX: "current_address_index";
+    /** Index of address nametags (JSON: { "0": "alice", "1": "bob" }) - for discovery */
+    readonly ADDRESS_NAMETAGS: "address_nametags";
 };
 /** Default Nostr relays */
 declare const DEFAULT_NOSTR_RELAYS: readonly ["wss://relay.unicity.network", "wss://relay.damus.io", "wss://nos.lol", "wss://relay.nostr.band"];
@@ -1941,7 +2024,7 @@ declare const DEFAULT_IPFS_GATEWAYS: readonly ["https://ipfs.unicity.network", "
 /** Unicity IPFS bootstrap peers */
 declare const DEFAULT_IPFS_BOOTSTRAP_PEERS: readonly ["/dns4/unicity-ipfs2.dyndns.org/tcp/4001/p2p/12D3KooWLNi5NDPPHbrfJakAQqwBqymYTTwMQXQKEWuCrJNDdmfh", "/dns4/unicity-ipfs3.dyndns.org/tcp/4001/p2p/12D3KooWQ4aujVE4ShLjdusNZBdffq3TbzrwT2DuWZY9H1Gxhwn6", "/dns4/unicity-ipfs4.dyndns.org/tcp/4001/p2p/12D3KooWJ1ByPfUzUrpYvgxKU8NZrR8i6PU1tUgMEbQX9Hh2DEn1", "/dns4/unicity-ipfs5.dyndns.org/tcp/4001/p2p/12D3KooWB1MdZZGHN5B8TvWXntbycfe7Cjcz7n6eZ9eykZadvmDv"];
 /** Default BIP32 derivation path (full path with chain/index) */
-declare const DEFAULT_DERIVATION_PATH$1: "m/44'/0'/0'/0/0";
+declare const DEFAULT_DERIVATION_PATH: "m/44'/0'/0'/0/0";
 /** Coin types */
 declare const COIN_TYPES: {
     /** ALPHA token (L1 blockchain) */
@@ -2191,6 +2274,7 @@ declare class Sphere$1 {
     private _derivationMode;
     private _basePath;
     private _currentAddressIndex;
+    /** Map of addressId -> (nametagIndex -> nametag). Supports multiple nametags per address (e.g., from Nostr recovery) */
     private _addressNametags;
     private _storage;
     private _tokenStorageProviders;
@@ -2244,6 +2328,7 @@ declare class Sphere$1 {
     static import(options: SphereImportOptions): Promise<Sphere$1>;
     /**
      * Clear wallet data from storage
+     * Note: Token data is cleared via TokenStorageProvider, not here
      */
     static clear(storage: StorageProvider): Promise<void>;
     /**
@@ -2462,18 +2547,29 @@ declare class Sphere$1 {
      */
     getCurrentAddressIndex(): number;
     /**
-     * Get nametag for a specific address index
+     * Get primary nametag for a specific address
+     *
+     * @param addressId - Address identifier (DIRECT://xxx), defaults to current address
+     * @returns Primary nametag (index 0) or undefined if not registered
+     */
+    getNametagForAddress(addressId?: string): string | undefined;
+    /**
+     * Get all nametags for a specific address
      *
-     * @param index - Address index (default: current address)
-     * @returns Nametag or undefined if not registered
+     * @param addressId - Address identifier (DIRECT://xxx), defaults to current address
+     * @returns Map of nametagIndex to nametag, or undefined if no nametags
      */
-    getNametagForAddress(index?: number): string | undefined;
+    getNametagsForAddress(addressId?: string): Map<number, string> | undefined;
     /**
      * Get all registered address nametags
      *
-     * @returns Map of address index to nametag
+     * @returns Map of addressId to (nametagIndex -> nametag)
      */
-    getAllAddressNametags(): Map<number, string>;
+    getAllAddressNametags(): Map<string, Map<number, string>>;
+    /**
+     * Get current address identifier (DIRECT://xxx format)
+     */
+    private getCurrentAddressId;
     /**
      * Switch to a different address by index
      * This changes the active identity to the derived address at the specified index.
@@ -2571,6 +2667,13 @@ declare class Sphere$1 {
      * Check if nametag is registered
      */
     hasNametag(): boolean;
+    /**
+     * Get the PROXY address for the current nametag
+     * PROXY addresses are derived from the nametag hash and require
+     * the nametag token to claim funds sent to them
+     * @returns PROXY address string or undefined if no nametag
+     */
+    getProxyAddress(): string | undefined;
     /**
      * Register a nametag for the current active address
      * Each address can have its own independent nametag
@@ -2592,6 +2695,7 @@ declare class Sphere$1 {
     registerNametag(nametag: string): Promise<void>;
     /**
      * Persist address nametags to storage
+     * Format: { "DIRECT://abc...xyz": { "0": "alice", "1": "alice2" }, ... }
      */
     private persistAddressNametags;
     /**
@@ -2621,6 +2725,8 @@ declare class Sphere$1 {
     isNametagAvailable(nametag: string): Promise<boolean>;
     /**
      * Load address nametags from storage
+     * Supports new format: { "DIRECT://abc...xyz": { "0": "alice" } }
+     * And legacy format: { "0": "alice" } (migrates to new format on save)
      */
     private loadAddressNametags;
     /**
@@ -2628,6 +2734,12 @@ declare class Sphere$1 {
      * If local nametag exists but not registered on Nostr, re-register it
      */
     private syncNametagWithNostr;
+    /**
+     * Recover nametag from Nostr after wallet import
+     * Searches for encrypted nametag events authored by this wallet's pubkey
+     * and decrypts them to restore the nametag association
+     */
+    private recoverNametagFromNostr;
     /**
      * Validate nametag format
      */
@@ -4806,6 +4918,7 @@ var L1PaymentsModule = class {
   _chainCode;
   _addresses = [];
   _wallet;
+  _transport;
   constructor(config) {
     this._config = {
       electrumUrl: config?.electrumUrl ?? "wss://fulcrum.alpha.unicity.network:50004",
@@ -4818,13 +4931,14 @@ var L1PaymentsModule = class {
     this._identity = deps.identity;
     this._chainCode = deps.chainCode;
     this._addresses = deps.addresses ?? [];
+    this._transport = deps.transport;
     this._wallet = {
       masterPrivateKey: deps.identity.privateKey,
       chainCode: deps.chainCode,
       addresses: [
         {
-          address: deps.identity.address,
-          publicKey: deps.identity.publicKey,
+          address: deps.identity.l1Address,
+          publicKey: deps.identity.chainPubkey,
           privateKey: deps.identity.privateKey,
           path: "m/0",
           index: 0
@@ -4832,7 +4946,7 @@ var L1PaymentsModule = class {
       ]
     };
     for (const addr of this._addresses) {
-      if (addr !== deps.identity.address) {
+      if (addr !== deps.identity.l1Address) {
         this._wallet.addresses.push({
           address: addr,
           path: null,
@@ -4855,18 +4969,64 @@ var L1PaymentsModule = class {
     this._addresses = [];
     this._wallet = void 0;
   }
+  /**
+   * Check if a string looks like an L1 address (alpha1... or alphat1...)
+   */
+  isL1Address(value) {
+    return value.startsWith("alpha1") || value.startsWith("alphat1");
+  }
+  /**
+   * Resolve recipient to L1 address
+   * Supports: L1 address (alpha1...), nametag (with or without @)
+   */
+  async resolveL1Address(recipient) {
+    if (recipient.startsWith("@")) {
+      const nametag = recipient.slice(1);
+      return this.resolveNametagToL1Address(nametag);
+    }
+    if (this.isL1Address(recipient)) {
+      return recipient;
+    }
+    try {
+      const l1Address = await this.resolveNametagToL1Address(recipient);
+      return l1Address;
+    } catch {
+      throw new Error(
+        `Recipient "${recipient}" is not a valid nametag or L1 address. Use @nametag for explicit nametag or a valid alpha1... address.`
+      );
+    }
+  }
+  /**
+   * Resolve nametag to L1 address using transport provider
+   */
+  async resolveNametagToL1Address(nametag) {
+    if (!this._transport?.resolveNametagInfo) {
+      throw new Error("Transport provider does not support nametag resolution");
+    }
+    const info = await this._transport.resolveNametagInfo(nametag);
+    if (!info) {
+      throw new Error(`Nametag not found: ${nametag}`);
+    }
+    if (!info.l1Address) {
+      throw new Error(
+        `Nametag @${nametag} does not have L1 address information. The owner needs to update their nametag registration.`
+      );
+    }
+    return info.l1Address;
+  }
   async send(request) {
     this.ensureInitialized();
     if (!this._wallet || !this._identity) {
       return { success: false, error: "No wallet available" };
     }
     try {
+      const recipientAddress = await this.resolveL1Address(request.to);
       const amountAlpha = parseInt(request.amount, 10) / 1e8;
       const results = await sendAlpha$1(
         this._wallet,
-        request.to,
+        recipientAddress,
         amountAlpha,
-        this._identity.address
+        this._identity.l1Address
       );
       if (results && results.length > 0) {
         const txids = results.map((r) => r.txid);
@@ -5088,8 +5248,8 @@ var L1PaymentsModule = class {
   }
   _getWatchedAddresses() {
     const addresses = [...this._addresses];
-    if (this._identity?.address && !addresses.includes(this._identity.address)) {
-      addresses.unshift(this._identity.address);
+    if (this._identity?.l1Address && !addresses.includes(this._identity.l1Address)) {
+      addresses.unshift(this._identity.l1Address);
     }
     return addresses;
   }
@@ -5531,54 +5691,49 @@ var NametagMinter = class {
     }
   }
 };
-
-// constants.ts
-var STORAGE_PREFIX = "sphere_";
 var DEFAULT_ENCRYPTION_KEY = "sphere-default-key";
-var STORAGE_KEYS = {
+var STORAGE_KEYS_GLOBAL = {
   /** Encrypted BIP39 mnemonic */
-  MNEMONIC: `${STORAGE_PREFIX}mnemonic`,
+  MNEMONIC: "mnemonic",
   /** Encrypted master private key */
-  MASTER_KEY: `${STORAGE_PREFIX}master_key`,
+  MASTER_KEY: "master_key",
   /** BIP32 chain code */
-  CHAIN_CODE: `${STORAGE_PREFIX}chain_code`,
+  CHAIN_CODE: "chain_code",
   /** HD derivation path (full path like m/44'/0'/0'/0/0) */
-  DERIVATION_PATH: `${STORAGE_PREFIX}derivation_path`,
+  DERIVATION_PATH: "derivation_path",
   /** Base derivation path (like m/44'/0'/0' without chain/index) */
-  BASE_PATH: `${STORAGE_PREFIX}base_path`,
+  BASE_PATH: "base_path",
   /** Derivation mode: bip32, wif_hmac, legacy_hmac */
-  DERIVATION_MODE: `${STORAGE_PREFIX}derivation_mode`,
+  DERIVATION_MODE: "derivation_mode",
   /** Wallet source: mnemonic, file, unknown */
-  WALLET_SOURCE: `${STORAGE_PREFIX}wallet_source`,
+  WALLET_SOURCE: "wallet_source",
   /** Wallet existence flag */
-  WALLET_EXISTS: `${STORAGE_PREFIX}wallet_exists`,
-  /** Registered nametag (legacy - single address) */
-  NAMETAG: `${STORAGE_PREFIX}nametag`,
+  WALLET_EXISTS: "wallet_exists",
   /** Current active address index */
-  CURRENT_ADDRESS_INDEX: `${STORAGE_PREFIX}current_address_index`,
-  /** Address nametags map (JSON: { "0": "alice", "1": "bob" }) */
-  ADDRESS_NAMETAGS: `${STORAGE_PREFIX}address_nametags`,
-  /** Token data */
-  TOKENS: `${STORAGE_PREFIX}tokens`,
-  /** Pending transfers */
-  PENDING_TRANSFERS: `${STORAGE_PREFIX}pending_transfers`,
-  /** Transfer outbox */
-  OUTBOX: `${STORAGE_PREFIX}outbox`,
-  /** Conversations */
-  CONVERSATIONS: `${STORAGE_PREFIX}conversations`,
-  /** Messages */
-  MESSAGES: `${STORAGE_PREFIX}messages`,
-  /** Transaction history */
-  TRANSACTION_HISTORY: `${STORAGE_PREFIX}transaction_history`,
-  /** Archived tokens (spent token history) */
-  ARCHIVED_TOKENS: `${STORAGE_PREFIX}archived_tokens`,
-  /** Tombstones (records of deleted/spent tokens) */
-  TOMBSTONES: `${STORAGE_PREFIX}tombstones`,
-  /** Forked tokens (alternative histories) */
-  FORKED_TOKENS: `${STORAGE_PREFIX}forked_tokens`
+  CURRENT_ADDRESS_INDEX: "current_address_index",
+  /** Index of address nametags (JSON: { "0": "alice", "1": "bob" }) - for discovery */
+  ADDRESS_NAMETAGS: "address_nametags"
 };
+var STORAGE_KEYS_ADDRESS = {
+  /** Pending transfers for this address */
+  PENDING_TRANSFERS: "pending_transfers",
+  /** Transfer outbox for this address */
+  OUTBOX: "outbox",
+  /** Transaction history for this address */
+  TRANSACTION_HISTORY: "transaction_history"
+};
+function getAddressId(directAddress) {
+  let hash = directAddress;
+  if (hash.startsWith("DIRECT://")) {
+    hash = hash.slice(9);
+  } else if (hash.startsWith("DIRECT:")) {
+    hash = hash.slice(7);
+  }
+  const first = hash.slice(0, 6).toLowerCase();
+  const last = hash.slice(-6).toLowerCase();
+  return `DIRECT_${first}_${last}`;
+}
 var DEFAULT_BASE_PATH = "m/44'/0'/0'";
-var DEFAULT_DERIVATION_PATH = `${DEFAULT_BASE_PATH}/0/0`;
 var LIMITS = {
   /** Min nametag length */
   NAMETAG_MIN_LENGTH: 3,
@@ -5740,6 +5895,7 @@ function txfToToken(tokenId, txf) {
     coinId,
     symbol: isNft ? "NFT" : "UCT",
     name: isNft ? "NFT" : "Token",
+    decimals: isNft ? 0 : 8,
     amount: totalAmount.toString(),
     status: determineTokenStatus(txf),
     createdAt: now,
@@ -5754,9 +5910,6 @@ async function buildTxfStorageData(tokens, meta, options) {
       formatVersion: "2.0"
     }
   };
-  if (options?.nametag) {
-    storageData._nametag = options.nametag;
-  }
   if (options?.tombstones && options.tombstones.length > 0) {
     storageData._tombstones = options.tombstones;
   }
@@ -5880,26 +6033,335 @@ function parseTxfStorageData(data) {
       }
     }
   }
-  return result;
-}
-function getCurrentStateHash(txf) {
-  if (txf.transactions && txf.transactions.length > 0) {
-    const lastTx = txf.transactions[txf.transactions.length - 1];
-    if (lastTx?.newStateHash) {
-      return lastTx.newStateHash;
+  return result;
+}
+function getCurrentStateHash(txf) {
+  if (txf.transactions && txf.transactions.length > 0) {
+    const lastTx = txf.transactions[txf.transactions.length - 1];
+    if (lastTx?.newStateHash) {
+      return lastTx.newStateHash;
+    }
+    return void 0;
+  }
+  if (txf._integrity?.currentStateHash) {
+    return txf._integrity.currentStateHash;
+  }
+  return void 0;
+}
+
+// registry/token-registry.testnet.json
+var token_registry_testnet_default = [
+  {
+    network: "unicity:testnet",
+    assetKind: "non-fungible",
+    name: "unicity",
+    description: "Unicity testnet token type",
+    id: "f8aa13834268d29355ff12183066f0cb902003629bbc5eb9ef0efbe397867509"
+  },
+  {
+    network: "unicity:testnet",
+    assetKind: "fungible",
+    name: "unicity",
+    symbol: "UCT",
+    decimals: 18,
+    description: "Unicity testnet native coin",
+    icons: [
+      { url: "https://raw.githubusercontent.com/unicitynetwork/unicity-ids/refs/heads/main/unicity_logo_32.png" }
+    ],
+    id: "455ad8720656b08e8dbd5bac1f3c73eeea5431565f6c1c3af742b1aa12d41d89"
+  },
+  {
+    network: "unicity:testnet",
+    assetKind: "fungible",
+    name: "unicity-usd",
+    symbol: "USDU",
+    decimals: 6,
+    description: "Unicity testnet USD stablecoin",
+    icons: [
+      { url: "https://raw.githubusercontent.com/unicitynetwork/unicity-ids/refs/heads/main/usdu_logo_32.png" }
+    ],
+    id: "8f0f3d7a5e7297be0ee98c63b81bcebb2740f43f616566fc290f9823a54f52d7"
+  },
+  {
+    network: "unicity:testnet",
+    assetKind: "fungible",
+    name: "unicity-eur",
+    symbol: "EURU",
+    decimals: 6,
+    description: "Unicity testnet EUR stablecoin",
+    icons: [
+      { url: "https://raw.githubusercontent.com/unicitynetwork/unicity-ids/refs/heads/main/euru_logo_32.png" }
+    ],
+    id: "5e160d5e9fdbb03b553fb9c3f6e6c30efa41fa807be39fb4f18e43776e492925"
+  },
+  {
+    network: "unicity:testnet",
+    assetKind: "fungible",
+    name: "solana",
+    symbol: "SOL",
+    decimals: 9,
+    description: "Solana testnet coin on Unicity",
+    icons: [
+      { url: "https://raw.githubusercontent.com/spothq/cryptocurrency-icons/master/svg/icon/sol.svg" },
+      { url: "https://raw.githubusercontent.com/spothq/cryptocurrency-icons/master/32/icon/sol.png" }
+    ],
+    id: "dee5f8ce778562eec90e9c38a91296a023210ccc76ff4c29d527ac3eb64ade93"
+  },
+  {
+    network: "unicity:testnet",
+    assetKind: "fungible",
+    name: "bitcoin",
+    symbol: "BTC",
+    decimals: 8,
+    description: "Bitcoin testnet coin on Unicity",
+    icons: [
+      { url: "https://raw.githubusercontent.com/spothq/cryptocurrency-icons/master/svg/icon/btc.svg" },
+      { url: "https://raw.githubusercontent.com/spothq/cryptocurrency-icons/master/32/icon/btc.png" }
+    ],
+    id: "86bc190fcf7b2d07c6078de93db803578760148b16d4431aa2f42a3241ff0daa"
+  },
+  {
+    network: "unicity:testnet",
+    assetKind: "fungible",
+    name: "ethereum",
+    symbol: "ETH",
+    decimals: 18,
+    description: "Ethereum testnet coin on Unicity",
+    icons: [
+      { url: "https://raw.githubusercontent.com/spothq/cryptocurrency-icons/master/svg/icon/eth.svg" },
+      { url: "https://raw.githubusercontent.com/spothq/cryptocurrency-icons/master/32/icon/eth.png" }
+    ],
+    id: "3c2450f2fd867e7bb60c6a69d7ad0e53ce967078c201a3ecaa6074ed4c0deafb"
+  },
+  {
+    network: "unicity:testnet",
+    assetKind: "fungible",
+    name: "alpha_test",
+    symbol: "ALPHT",
+    decimals: 8,
+    description: "ALPHA testnet coin on Unicity",
+    icons: [
+      { url: "https://raw.githubusercontent.com/unicitynetwork/unicity-ids/refs/heads/main/alpha_coin.png" }
+    ],
+    id: "cde78ded16ef65818a51f43138031c4284e519300ab0cb60c30a8f9078080e5f"
+  },
+  {
+    network: "unicity:testnet",
+    assetKind: "fungible",
+    name: "tether",
+    symbol: "USDT",
+    decimals: 6,
+    description: "Tether (Ethereum) testnet coin on Unicity",
+    icons: [
+      { url: "https://raw.githubusercontent.com/spothq/cryptocurrency-icons/master/svg/icon/usdt.svg" },
+      { url: "https://raw.githubusercontent.com/spothq/cryptocurrency-icons/master/32/icon/usdt.png" }
+    ],
+    id: "40d25444648418fe7efd433e147187a3a6adf049ac62bc46038bda5b960bf690"
+  },
+  {
+    network: "unicity:testnet",
+    assetKind: "fungible",
+    name: "usd-coin",
+    symbol: "USDC",
+    decimals: 6,
+    description: "USDC (Ethereum) testnet coin on Unicity",
+    icons: [
+      { url: "https://raw.githubusercontent.com/spothq/cryptocurrency-icons/master/svg/icon/usdc.svg" },
+      { url: "https://raw.githubusercontent.com/spothq/cryptocurrency-icons/master/32/icon/usdc.png" }
+    ],
+    id: "2265121770fa6f41131dd9a6cc571e28679263d09a53eb2642e145b5b9a5b0a2"
+  }
+];
+
+// registry/TokenRegistry.ts
+var TokenRegistry$1 = class _TokenRegistry {
+  static instance = null;
+  definitionsById;
+  definitionsBySymbol;
+  definitionsByName;
+  constructor() {
+    this.definitionsById = /* @__PURE__ */ new Map();
+    this.definitionsBySymbol = /* @__PURE__ */ new Map();
+    this.definitionsByName = /* @__PURE__ */ new Map();
+    this.loadRegistry();
+  }
+  /**
+   * Get singleton instance of TokenRegistry
+   */
+  static getInstance() {
+    if (!_TokenRegistry.instance) {
+      _TokenRegistry.instance = new _TokenRegistry();
+    }
+    return _TokenRegistry.instance;
+  }
+  /**
+   * Reset the singleton instance (useful for testing)
+   */
+  static resetInstance() {
+    _TokenRegistry.instance = null;
+  }
+  /**
+   * Load registry data from bundled JSON
+   */
+  loadRegistry() {
+    const definitions = token_registry_testnet_default;
+    for (const def of definitions) {
+      const idLower = def.id.toLowerCase();
+      this.definitionsById.set(idLower, def);
+      if (def.symbol) {
+        this.definitionsBySymbol.set(def.symbol.toUpperCase(), def);
+      }
+      this.definitionsByName.set(def.name.toLowerCase(), def);
+    }
+  }
+  // ===========================================================================
+  // Lookup Methods
+  // ===========================================================================
+  /**
+   * Get token definition by hex coin ID
+   * @param coinId - 64-character hex string
+   * @returns Token definition or undefined if not found
+   */
+  getDefinition(coinId) {
+    if (!coinId) return void 0;
+    return this.definitionsById.get(coinId.toLowerCase());
+  }
+  /**
+   * Get token definition by symbol (e.g., "UCT", "BTC")
+   * @param symbol - Token symbol (case-insensitive)
+   * @returns Token definition or undefined if not found
+   */
+  getDefinitionBySymbol(symbol) {
+    if (!symbol) return void 0;
+    return this.definitionsBySymbol.get(symbol.toUpperCase());
+  }
+  /**
+   * Get token definition by name (e.g., "bitcoin", "ethereum")
+   * @param name - Token name (case-insensitive)
+   * @returns Token definition or undefined if not found
+   */
+  getDefinitionByName(name) {
+    if (!name) return void 0;
+    return this.definitionsByName.get(name.toLowerCase());
+  }
+  /**
+   * Get token symbol for a coin ID
+   * @param coinId - 64-character hex string
+   * @returns Symbol (e.g., "UCT") or truncated ID if not found
+   */
+  getSymbol(coinId) {
+    const def = this.getDefinition(coinId);
+    if (def?.symbol) {
+      return def.symbol;
+    }
+    return coinId.slice(0, 6).toUpperCase();
+  }
+  /**
+   * Get token name for a coin ID
+   * @param coinId - 64-character hex string
+   * @returns Name (e.g., "Bitcoin") or coin ID if not found
+   */
+  getName(coinId) {
+    const def = this.getDefinition(coinId);
+    if (def?.name) {
+      return def.name.charAt(0).toUpperCase() + def.name.slice(1);
     }
-    return void 0;
+    return coinId;
   }
-  if (txf._integrity?.currentStateHash) {
-    return txf._integrity.currentStateHash;
+  /**
+   * Get decimal places for a coin ID
+   * @param coinId - 64-character hex string
+   * @returns Decimals or 0 if not found
+   */
+  getDecimals(coinId) {
+    const def = this.getDefinition(coinId);
+    return def?.decimals ?? 0;
   }
-  return void 0;
+  /**
+   * Get icon URL for a coin ID
+   * @param coinId - 64-character hex string
+   * @param preferPng - Prefer PNG format over SVG
+   * @returns Icon URL or null if not found
+   */
+  getIconUrl(coinId, preferPng = true) {
+    const def = this.getDefinition(coinId);
+    if (!def?.icons || def.icons.length === 0) {
+      return null;
+    }
+    if (preferPng) {
+      const pngIcon = def.icons.find((i) => i.url.toLowerCase().includes(".png"));
+      if (pngIcon) return pngIcon.url;
+    }
+    return def.icons[0].url;
+  }
+  /**
+   * Check if a coin ID is known in the registry
+   * @param coinId - 64-character hex string
+   * @returns true if the coin is in the registry
+   */
+  isKnown(coinId) {
+    return this.definitionsById.has(coinId.toLowerCase());
+  }
+  /**
+   * Get all token definitions
+   * @returns Array of all token definitions
+   */
+  getAllDefinitions() {
+    return Array.from(this.definitionsById.values());
+  }
+  /**
+   * Get all fungible token definitions
+   * @returns Array of fungible token definitions
+   */
+  getFungibleTokens() {
+    return this.getAllDefinitions().filter((def) => def.assetKind === "fungible");
+  }
+  /**
+   * Get all non-fungible token definitions
+   * @returns Array of non-fungible token definitions
+   */
+  getNonFungibleTokens() {
+    return this.getAllDefinitions().filter((def) => def.assetKind === "non-fungible");
+  }
+  /**
+   * Get coin ID by symbol
+   * @param symbol - Token symbol (e.g., "UCT")
+   * @returns Coin ID hex string or undefined if not found
+   */
+  getCoinIdBySymbol(symbol) {
+    const def = this.getDefinitionBySymbol(symbol);
+    return def?.id;
+  }
+  /**
+   * Get coin ID by name
+   * @param name - Token name (e.g., "bitcoin")
+   * @returns Coin ID hex string or undefined if not found
+   */
+  getCoinIdByName(name) {
+    const def = this.getDefinitionByName(name);
+    return def?.id;
+  }
+};
+function enrichWithRegistry(info) {
+  const registry = TokenRegistry$1.getInstance();
+  const def = registry.getDefinition(info.coinId);
+  if (def) {
+    return {
+      ...info,
+      symbol: def.symbol || info.symbol,
+      name: def.name.charAt(0).toUpperCase() + def.name.slice(1),
+      decimals: def.decimals ?? 0,
+      iconUrl: registry.getIconUrl(info.coinId) ?? void 0
+    };
+  }
+  return info;
 }
 async function parseTokenInfo(tokenData) {
   const defaultInfo = {
     coinId: "ALPHA",
     symbol: "ALPHA",
     name: "Alpha Token",
+    decimals: 0,
     amount: "0"
   };
   try {
@@ -5920,23 +6382,25 @@ async function parseTokenInfo(tokenData) {
           }
           if (coinIdObj instanceof CoinId) {
             const coinIdHex = coinIdObj.toJSON();
-            return {
+            return enrichWithRegistry({
               coinId: coinIdHex,
               symbol: coinIdHex.slice(0, 8),
               name: `Token ${coinIdHex.slice(0, 8)}`,
+              decimals: 0,
               amount: String(amount ?? "0"),
               tokenId: defaultInfo.tokenId
-            };
+            });
           } else if (coinIdObj && typeof coinIdObj === "object" && "bytes" in coinIdObj) {
             const bytes = coinIdObj.bytes;
             const coinIdHex = Buffer.isBuffer(bytes) ? bytes.toString("hex") : Array.isArray(bytes) ? Buffer.from(bytes).toString("hex") : String(bytes);
-            return {
+            return enrichWithRegistry({
               coinId: coinIdHex,
               symbol: coinIdHex.slice(0, 8),
               name: `Token ${coinIdHex.slice(0, 8)}`,
+              decimals: 0,
               amount: String(amount ?? "0"),
               tokenId: defaultInfo.tokenId
-            };
+            });
           }
         }
       }
@@ -5951,13 +6415,14 @@ async function parseTokenInfo(tokenData) {
             if (Array.isArray(firstEntry) && firstEntry.length === 2) {
               const [coinIdHex, amount] = firstEntry;
               const coinIdStr = typeof coinIdHex === "string" ? coinIdHex : String(coinIdHex);
-              return {
+              return enrichWithRegistry({
                 coinId: coinIdStr,
                 symbol: coinIdStr.slice(0, 8),
                 name: `Token ${coinIdStr.slice(0, 8)}`,
+                decimals: 0,
                 amount: String(amount),
                 tokenId: defaultInfo.tokenId
-              };
+              });
             }
           }
         }
@@ -5972,25 +6437,27 @@ async function parseTokenInfo(tokenData) {
           const firstEntry = coinData[0];
           if (Array.isArray(firstEntry) && firstEntry.length === 2) {
             const [coinIdHex, amount] = firstEntry;
-            return {
+            return enrichWithRegistry({
               coinId: String(coinIdHex),
               symbol: String(coinIdHex).slice(0, 8),
               name: `Token ${String(coinIdHex).slice(0, 8)}`,
+              decimals: 0,
               amount: String(amount),
               tokenId: genesis.tokenId
-            };
+            });
           }
         } else if (typeof coinData === "object") {
           const coinEntries = Object.entries(coinData);
           if (coinEntries.length > 0) {
             const [coinId, amount] = coinEntries[0];
-            return {
+            return enrichWithRegistry({
               coinId,
               symbol: coinId.slice(0, 8),
               name: `Token ${coinId.slice(0, 8)}`,
+              decimals: 0,
               amount: String(amount),
               tokenId: genesis.tokenId
-            };
+            });
           }
         }
       }
@@ -6004,25 +6471,27 @@ async function parseTokenInfo(tokenData) {
         const firstEntry = coinData[0];
         if (Array.isArray(firstEntry) && firstEntry.length === 2) {
           const [coinIdHex, amount] = firstEntry;
-          return {
+          return enrichWithRegistry({
             coinId: String(coinIdHex),
             symbol: String(coinIdHex).slice(0, 8),
             name: `Token ${String(coinIdHex).slice(0, 8)}`,
+            decimals: 0,
             amount: String(amount),
             tokenId: defaultInfo.tokenId
-          };
+          });
         }
       } else if (typeof coinData === "object") {
         const coinEntries = Object.entries(coinData);
         if (coinEntries.length > 0) {
           const [coinId, amount] = coinEntries[0];
-          return {
+          return enrichWithRegistry({
             coinId,
             symbol: coinId.slice(0, 8),
             name: `Token ${coinId.slice(0, 8)}`,
+            decimals: 0,
             amount: String(amount),
             tokenId: defaultInfo.tokenId
-          };
+          });
         }
       }
     }
@@ -6181,7 +6650,8 @@ var PaymentsModule = class {
       this.l1.initialize({
         identity: deps.identity,
         chainCode: deps.chainCode,
-        addresses: deps.l1Addresses
+        addresses: deps.l1Addresses,
+        transport: deps.transport
       });
     }
     this.unsubscribeTransfers = deps.transport.onTokenTransfer((transfer) => {
@@ -6203,37 +6673,24 @@ var PaymentsModule = class {
    */
   async load() {
     this.ensureInitialized();
-    const data = await this.deps.storage.get(STORAGE_KEYS.TOKENS);
-    if (data) {
+    const providers = this.getTokenStorageProviders();
+    for (const [id, provider] of providers) {
       try {
-        const parsed = JSON.parse(data);
-        const tokens = parsed.tokens || [];
-        this.tokens.clear();
-        for (const token of tokens) {
-          this.tokens.set(token.id, token);
-        }
-        if (Array.isArray(parsed.tombstones)) {
-          this.tombstones = parsed.tombstones.filter(
-            (t) => typeof t === "object" && t !== null && typeof t.tokenId === "string" && typeof t.stateHash === "string"
-          );
-        }
-        if (parsed.archivedTokens && typeof parsed.archivedTokens === "object") {
-          this.archivedTokens = new Map(Object.entries(parsed.archivedTokens));
-        }
-        if (parsed.forkedTokens && typeof parsed.forkedTokens === "object") {
-          this.forkedTokens = new Map(Object.entries(parsed.forkedTokens));
-        }
-        if (parsed.nametag) {
-          this.nametag = parsed.nametag;
+        const result = await provider.load();
+        if (result.success && result.data) {
+          this.loadFromStorageData(result.data);
+          this.log(`Loaded from provider ${id}: ${this.tokens.size} tokens`);
+          break;
         }
-        this.log(`Loaded ${this.tokens.size} tokens, ${this.tombstones.length} tombstones, ${this.archivedTokens.size} archived`);
       } catch (err) {
-        console.error("[Payments] Failed to parse stored data:", err);
+        console.error(`[Payments] Failed to load from provider ${id}:`, err);
       }
     }
-    await this.loadTokensFromFileStorage();
+    if (this.tokens.size === 0) {
+      await this.loadTokensFromFileStorage();
+    }
     await this.loadNametagFromFileStorage();
-    const historyData = await this.deps.storage.get(STORAGE_KEYS.TRANSACTION_HISTORY);
+    const historyData = await this.deps.storage.get(STORAGE_KEYS_ADDRESS.TRANSACTION_HISTORY);
     if (historyData) {
       try {
         this.transactionHistory = JSON.parse(historyData);
@@ -6241,7 +6698,7 @@ var PaymentsModule = class {
         this.transactionHistory = [];
       }
     }
-    const pending2 = await this.deps.storage.get(STORAGE_KEYS.PENDING_TRANSFERS);
+    const pending2 = await this.deps.storage.get(STORAGE_KEYS_ADDRESS.PENDING_TRANSFERS);
     if (pending2) {
       const transfers = JSON.parse(pending2);
       for (const transfer of transfers) {
@@ -6339,6 +6796,8 @@ var PaymentsModule = class {
           coinId: request.coinId,
           symbol: this.getCoinSymbol(request.coinId),
           name: this.getCoinName(request.coinId),
+          decimals: this.getCoinDecimals(request.coinId),
+          iconUrl: this.getCoinIconUrl(request.coinId),
           amount: splitPlan.remainderAmount.toString(),
           status: "confirmed",
           createdAt: Date.now(),
@@ -6407,20 +6866,25 @@ var PaymentsModule = class {
    * Get coin symbol from coinId
    */
   getCoinSymbol(coinId) {
-    const symbols = {
-      "UCT": "UCT"
-      // Add more as needed
-    };
-    return symbols[coinId] || coinId.slice(0, 6).toUpperCase();
+    return TokenRegistry$1.getInstance().getSymbol(coinId);
   }
   /**
    * Get coin name from coinId
    */
   getCoinName(coinId) {
-    const names = {
-      "UCT": "Unicity Token"
-    };
-    return names[coinId] || coinId;
+    return TokenRegistry$1.getInstance().getName(coinId);
+  }
+  /**
+   * Get coin decimals from coinId
+   */
+  getCoinDecimals(coinId) {
+    return TokenRegistry$1.getInstance().getDecimals(coinId);
+  }
+  /**
+   * Get coin icon URL from coinId
+   */
+  getCoinIconUrl(coinId) {
+    return TokenRegistry$1.getInstance().getIconUrl(coinId) ?? void 0;
   }
   // ===========================================================================
   // Public API - Payment Requests
@@ -6578,7 +7042,7 @@ var PaymentsModule = class {
     }
     const request = {
       id: transportRequest.id,
-      senderPubkey: transportRequest.senderPubkey,
+      senderPubkey: transportRequest.senderTransportPubkey,
       amount: transportRequest.request.amount,
       coinId: transportRequest.request.coinId,
       symbol: transportRequest.request.coinId,
@@ -6690,7 +7154,7 @@ var PaymentsModule = class {
     }
     const response = {
       id: transportResponse.id,
-      responderPubkey: transportResponse.responderPubkey,
+      responderPubkey: transportResponse.responderTransportPubkey,
       requestId: transportResponse.response.requestId,
       responseType: transportResponse.response.responseType,
       message: transportResponse.response.message,
@@ -6895,6 +7359,8 @@ var PaymentsModule = class {
               coinId: tokenInfo.coinId,
               symbol: tokenInfo.symbol,
               name: tokenInfo.name,
+              decimals: tokenInfo.decimals,
+              iconUrl: tokenInfo.iconUrl,
               amount: tokenInfo.amount,
               status: "confirmed",
               createdAt: data.receivedAt || Date.now(),
@@ -7150,7 +7616,7 @@ var PaymentsModule = class {
     };
     this.transactionHistory.push(historyEntry);
     await this.deps.storage.set(
-      STORAGE_KEYS.TRANSACTION_HISTORY,
+      STORAGE_KEYS_ADDRESS.TRANSACTION_HISTORY,
       JSON.stringify(this.transactionHistory)
     );
   }
@@ -7444,6 +7910,23 @@ var PaymentsModule = class {
   // ===========================================================================
   // Private: Transfer Operations
   // ===========================================================================
+  /**
+   * Detect if a string is an L3 address (not a nametag)
+   * Returns true for: hex pubkeys (64+ chars), PROXY:, DIRECT: prefixed addresses
+   */
+  isL3Address(value) {
+    if (value.startsWith("PROXY:") || value.startsWith("DIRECT:")) {
+      return true;
+    }
+    if (value.length >= 64 && /^[0-9a-fA-F]+$/.test(value)) {
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Resolve recipient to Nostr pubkey for messaging
+   * Supports: nametag (with or without @), hex pubkey
+   */
   async resolveRecipient(recipient) {
     if (recipient.startsWith("@")) {
       const nametag = recipient.slice(1);
@@ -7453,7 +7936,19 @@ var PaymentsModule = class {
       }
       return pubkey;
     }
-    return recipient;
+    if (this.isL3Address(recipient)) {
+      return recipient;
+    }
+    if (this.deps?.transport.resolveNametag) {
+      const pubkey = await this.deps.transport.resolveNametag(recipient);
+      if (pubkey) {
+        this.log(`Resolved "${recipient}" as nametag to pubkey`);
+        return pubkey;
+      }
+    }
+    throw new Error(
+      `Recipient "${recipient}" is not a valid nametag or address. Use @nametag for explicit nametag or a valid hex pubkey/PROXY:/DIRECT: address.`
+    );
   }
   /**
    * Create SDK TransferCommitment for a token transfer
@@ -7485,19 +7980,74 @@ var PaymentsModule = class {
     return SigningService.createFromSecret(privateKeyBytes);
   }
   /**
-   * Resolve recipient to IAddress
+   * Create DirectAddress from a public key using UnmaskedPredicateReference
+   */
+  async createDirectAddressFromPubkey(pubkeyHex) {
+    const { UnmaskedPredicateReference: UnmaskedPredicateReference3 } = await import('@unicitylabs/state-transition-sdk/lib/predicate/embedded/UnmaskedPredicateReference');
+    const { TokenType: TokenType3 } = await import('@unicitylabs/state-transition-sdk/lib/token/TokenType');
+    const UNICITY_TOKEN_TYPE_HEX3 = "f8aa13834268d29355ff12183066f0cb902003629bbc5eb9ef0efbe397867509";
+    const tokenType = new TokenType3(Buffer.from(UNICITY_TOKEN_TYPE_HEX3, "hex"));
+    const pubkeyBytes = new Uint8Array(
+      pubkeyHex.match(/.{1,2}/g).map((byte) => parseInt(byte, 16))
+    );
+    const addressRef = await UnmaskedPredicateReference3.create(
+      tokenType,
+      "secp256k1",
+      pubkeyBytes,
+      HashAlgorithm.SHA256
+    );
+    return addressRef.toAddress();
+  }
+  /**
+   * Resolve nametag to 33-byte compressed public key using resolveNametagInfo
+   * Returns null if nametag not found or publicKey not available
+   */
+  async resolveNametagToPublicKey(nametag) {
+    if (!this.deps?.transport.resolveNametagInfo) {
+      this.log("resolveNametagInfo not available on transport");
+      return null;
+    }
+    const info = await this.deps.transport.resolveNametagInfo(nametag);
+    if (!info) {
+      this.log(`Nametag "${nametag}" not found`);
+      return null;
+    }
+    if (!info.chainPubkey) {
+      this.log(`Nametag "${nametag}" has no 33-byte chainPubkey (legacy event)`);
+      return null;
+    }
+    return info.chainPubkey;
+  }
+  /**
+   * Resolve recipient to IAddress for L3 transfers
+   * Supports: nametag (with or without @), PROXY:, DIRECT:, hex pubkey
    */
   async resolveRecipientAddress(recipient) {
+    const { AddressFactory } = await import('@unicitylabs/state-transition-sdk/lib/address/AddressFactory');
     if (recipient.startsWith("@")) {
       const nametag = recipient.slice(1);
-      const tokenId2 = await TokenId.fromNameTag(nametag);
-      return ProxyAddress.fromTokenId(tokenId2);
+      const publicKey2 = await this.resolveNametagToPublicKey(nametag);
+      if (publicKey2) {
+        this.log(`Resolved @${nametag} to 33-byte publicKey for DirectAddress`);
+        return this.createDirectAddressFromPubkey(publicKey2);
+      }
+      throw new Error(`Nametag "${nametag}" not found or missing publicKey`);
     }
-    const pubkeyBytes = new Uint8Array(
-      recipient.match(/.{1,2}/g).map((byte) => parseInt(byte, 16))
+    if (recipient.startsWith("PROXY:") || recipient.startsWith("DIRECT:")) {
+      return AddressFactory.createAddress(recipient);
+    }
+    if (recipient.length === 66 && /^[0-9a-fA-F]+$/.test(recipient)) {
+      this.log(`Creating DirectAddress from 33-byte compressed pubkey`);
+      return this.createDirectAddressFromPubkey(recipient);
+    }
+    const publicKey = await this.resolveNametagToPublicKey(recipient);
+    if (publicKey) {
+      this.log(`Resolved "${recipient}" as nametag to 33-byte publicKey for DirectAddress`);
+      return this.createDirectAddressFromPubkey(publicKey);
+    }
+    throw new Error(
+      `Recipient "${recipient}" is not a valid nametag or L3 address. Use @nametag for explicit nametag or a valid 33-byte hex pubkey/PROXY:/DIRECT: address.`
     );
-    const tokenId = new TokenId(pubkeyBytes.slice(0, 32));
-    return ProxyAddress.fromTokenId(tokenId);
   }
   async handleIncomingTransfer(transfer) {
     try {
@@ -7555,7 +8105,39 @@ var PaymentsModule = class {
             }
           }
         } else {
-          tokenData = sourceTokenInput;
+          this.log("Finalizing DIRECT address transfer for state tracking...");
+          try {
+            const signingService = await this.createSigningService();
+            const transferSalt = transferTx.data.salt;
+            const recipientPredicate = await UnmaskedPredicate.create(
+              sourceToken.id,
+              sourceToken.type,
+              signingService,
+              HashAlgorithm.SHA256,
+              transferSalt
+            );
+            const recipientState = new TokenState$1(recipientPredicate, null);
+            const stClient = this.deps.oracle.getStateTransitionClient?.();
+            const trustBase = this.deps.oracle.getTrustBase?.();
+            if (!stClient || !trustBase) {
+              this.log("Cannot finalize DIRECT transfer - missing client, using source token");
+              tokenData = sourceTokenInput;
+            } else {
+              finalizedSdkToken = await stClient.finalizeTransaction(
+                trustBase,
+                sourceToken,
+                recipientState,
+                transferTx,
+                []
+                // No nametag tokens needed for DIRECT
+              );
+              tokenData = finalizedSdkToken.toJSON();
+              this.log("DIRECT transfer finalized successfully");
+            }
+          } catch (finalizeError) {
+            this.log("DIRECT finalization failed, using source token:", finalizeError);
+            tokenData = sourceTokenInput;
+          }
         }
       } else if (payload.token) {
         tokenData = payload.token;
@@ -7574,6 +8156,8 @@ var PaymentsModule = class {
         coinId: tokenInfo.coinId,
         symbol: tokenInfo.symbol,
         name: tokenInfo.name,
+        decimals: tokenInfo.decimals,
+        iconUrl: tokenInfo.iconUrl,
         amount: tokenInfo.amount,
         status: "confirmed",
         createdAt: Date.now(),
@@ -7589,7 +8173,7 @@ var PaymentsModule = class {
       await this.addToken(token);
       const incomingTransfer = {
         id: transfer.id,
-        senderPubkey: transfer.senderPubkey,
+        senderPubkey: transfer.senderTransportPubkey,
         tokens: [token],
         memo: payload.memo,
         receivedAt: transfer.timestamp
@@ -7627,28 +8211,32 @@ var PaymentsModule = class {
   // Private: Storage
   // ===========================================================================
   async save() {
-    const tokens = Array.from(this.tokens.values());
-    const data = {
-      tokens,
-      tombstones: this.tombstones.length > 0 ? this.tombstones : void 0,
-      archivedTokens: this.archivedTokens.size > 0 ? Object.fromEntries(this.archivedTokens) : void 0,
-      forkedTokens: this.forkedTokens.size > 0 ? Object.fromEntries(this.forkedTokens) : void 0,
-      nametag: this.nametag || void 0
-    };
-    await this.deps.storage.set(STORAGE_KEYS.TOKENS, JSON.stringify(data));
+    const providers = this.getTokenStorageProviders();
+    if (providers.size === 0) {
+      this.log("No token storage providers - tokens not persisted");
+      return;
+    }
+    const data = await this.createStorageData();
+    for (const [id, provider] of providers) {
+      try {
+        await provider.save(data);
+      } catch (err) {
+        console.error(`[Payments] Failed to save to provider ${id}:`, err);
+      }
+    }
   }
   async saveToOutbox(transfer, recipient) {
     const outbox = await this.loadOutbox();
     outbox.push({ transfer, recipient, createdAt: Date.now() });
-    await this.deps.storage.set(STORAGE_KEYS.OUTBOX, JSON.stringify(outbox));
+    await this.deps.storage.set(STORAGE_KEYS_ADDRESS.OUTBOX, JSON.stringify(outbox));
   }
   async removeFromOutbox(transferId) {
     const outbox = await this.loadOutbox();
     const filtered = outbox.filter((e) => e.transfer.id !== transferId);
-    await this.deps.storage.set(STORAGE_KEYS.OUTBOX, JSON.stringify(filtered));
+    await this.deps.storage.set(STORAGE_KEYS_ADDRESS.OUTBOX, JSON.stringify(filtered));
   }
   async loadOutbox() {
-    const data = await this.deps.storage.get(STORAGE_KEYS.OUTBOX);
+    const data = await this.deps.storage.get(STORAGE_KEYS_ADDRESS.OUTBOX);
     return data ? JSON.parse(data) : [];
   }
   async createStorageData() {
@@ -7657,11 +8245,10 @@ var PaymentsModule = class {
       tokens,
       {
         version: 1,
-        address: this.deps.identity.address,
+        address: this.deps.identity.l1Address,
         ipnsName: this.deps.identity.ipnsName ?? ""
       },
       {
-        nametag: this.nametag || void 0,
         tombstones: this.tombstones,
         archivedTokens: this.archivedTokens,
         forkedTokens: this.forkedTokens
@@ -7761,7 +8348,7 @@ var CommunicationsModule = class {
     const eventId = await this.deps.transport.sendMessage(recipientPubkey, content);
     const message = {
       id: eventId,
-      senderPubkey: this.deps.identity.publicKey,
+      senderPubkey: this.deps.identity.chainPubkey,
       senderNametag: this.deps.identity.nametag,
       recipientPubkey,
       content,
@@ -7788,7 +8375,7 @@ var CommunicationsModule = class {
   getConversations() {
     const conversations = /* @__PURE__ */ new Map();
     for (const message of this.messages.values()) {
-      const peer = message.senderPubkey === this.deps?.identity.publicKey ? message.recipientPubkey : message.senderPubkey;
+      const peer = message.senderPubkey === this.deps?.identity.chainPubkey ? message.recipientPubkey : message.senderPubkey;
       if (!conversations.has(peer)) {
         conversations.set(peer, []);
       }
@@ -7818,7 +8405,7 @@ var CommunicationsModule = class {
    */
   getUnreadCount(peerPubkey) {
     let messages = Array.from(this.messages.values()).filter(
-      (m) => !m.isRead && m.senderPubkey !== this.deps?.identity.publicKey
+      (m) => !m.isRead && m.senderPubkey !== this.deps?.identity.chainPubkey
     );
     if (peerPubkey) {
       messages = messages.filter((m) => m.senderPubkey === peerPubkey);
@@ -7843,7 +8430,7 @@ var CommunicationsModule = class {
     const eventId = await this.deps.transport.publishBroadcast?.(content, tags);
     const message = {
       id: eventId ?? crypto.randomUUID(),
-      authorPubkey: this.deps.identity.publicKey,
+      authorPubkey: this.deps.identity.chainPubkey,
       authorNametag: this.deps.identity.nametag,
       content,
       timestamp: Date.now(),
@@ -7894,11 +8481,12 @@ var CommunicationsModule = class {
   // Private: Message Handling
   // ===========================================================================
   handleIncomingMessage(msg) {
-    if (msg.senderPubkey === this.deps?.identity.publicKey) return;
+    if (msg.senderTransportPubkey === this.deps?.identity.chainPubkey) return;
     const message = {
       id: msg.id,
-      senderPubkey: msg.senderPubkey,
-      recipientPubkey: this.deps.identity.publicKey,
+      senderPubkey: msg.senderTransportPubkey,
+      senderNametag: msg.senderNametag,
+      recipientPubkey: this.deps.identity.chainPubkey,
       content: msg.content,
       timestamp: msg.timestamp,
       isRead: false
@@ -7920,7 +8508,7 @@ var CommunicationsModule = class {
   handleIncomingBroadcast(incoming) {
     const message = {
       id: incoming.id,
-      authorPubkey: incoming.authorPubkey,
+      authorPubkey: incoming.authorTransportPubkey,
       content: incoming.content,
       timestamp: incoming.timestamp,
       tags: incoming.tags
@@ -8638,6 +9226,7 @@ var Sphere = class _Sphere {
   _derivationMode = "bip32";
   _basePath = DEFAULT_BASE_PATH;
   _currentAddressIndex = 0;
+  /** Map of addressId -> (nametagIndex -> nametag). Supports multiple nametags per address (e.g., from Nostr recovery) */
   _addressNametags = /* @__PURE__ */ new Map();
   // Providers
   _storage;
@@ -8673,9 +9262,9 @@ var Sphere = class _Sphere {
       if (!storage.isConnected()) {
         await storage.connect();
       }
-      const mnemonic = await storage.get(STORAGE_KEYS.MNEMONIC);
+      const mnemonic = await storage.get(STORAGE_KEYS_GLOBAL.MNEMONIC);
       if (mnemonic) return true;
-      const masterKey = await storage.get(STORAGE_KEYS.MASTER_KEY);
+      const masterKey = await storage.get(STORAGE_KEYS_GLOBAL.MASTER_KEY);
       if (masterKey) return true;
       return false;
     } catch {
@@ -8769,6 +9358,8 @@ var Sphere = class _Sphere {
     _Sphere.instance = sphere;
     if (options.nametag) {
       await sphere.registerNametag(options.nametag);
+    } else {
+      await sphere.recoverNametagFromNostr();
     }
     return sphere;
   }
@@ -8831,6 +9422,9 @@ var Sphere = class _Sphere {
     }
     await sphere.initializeProviders();
     await sphere.initializeModules();
+    if (!options.nametag) {
+      await sphere.recoverNametagFromNostr();
+    }
     await sphere.finalizeWalletCreation();
     sphere._initialized = true;
     _Sphere.instance = sphere;
@@ -8841,20 +9435,20 @@ var Sphere = class _Sphere {
   }
   /**
    * Clear wallet data from storage
+   * Note: Token data is cleared via TokenStorageProvider, not here
    */
   static async clear(storage) {
-    await storage.remove(STORAGE_KEYS.MNEMONIC);
-    await storage.remove(STORAGE_KEYS.MASTER_KEY);
-    await storage.remove(STORAGE_KEYS.CHAIN_CODE);
-    await storage.remove(STORAGE_KEYS.DERIVATION_PATH);
-    await storage.remove(STORAGE_KEYS.BASE_PATH);
-    await storage.remove(STORAGE_KEYS.DERIVATION_MODE);
-    await storage.remove(STORAGE_KEYS.WALLET_SOURCE);
-    await storage.remove(STORAGE_KEYS.WALLET_EXISTS);
-    await storage.remove(STORAGE_KEYS.NAMETAG);
-    await storage.remove(STORAGE_KEYS.TOKENS);
-    await storage.remove(STORAGE_KEYS.PENDING_TRANSFERS);
-    await storage.remove(STORAGE_KEYS.OUTBOX);
+    await storage.remove(STORAGE_KEYS_GLOBAL.MNEMONIC);
+    await storage.remove(STORAGE_KEYS_GLOBAL.MASTER_KEY);
+    await storage.remove(STORAGE_KEYS_GLOBAL.CHAIN_CODE);
+    await storage.remove(STORAGE_KEYS_GLOBAL.DERIVATION_PATH);
+    await storage.remove(STORAGE_KEYS_GLOBAL.BASE_PATH);
+    await storage.remove(STORAGE_KEYS_GLOBAL.DERIVATION_MODE);
+    await storage.remove(STORAGE_KEYS_GLOBAL.WALLET_SOURCE);
+    await storage.remove(STORAGE_KEYS_GLOBAL.WALLET_EXISTS);
+    await storage.remove(STORAGE_KEYS_GLOBAL.ADDRESS_NAMETAGS);
+    await storage.remove(STORAGE_KEYS_ADDRESS.PENDING_TRANSFERS);
+    await storage.remove(STORAGE_KEYS_ADDRESS.OUTBOX);
     if (_Sphere.instance) {
       await _Sphere.instance.destroy();
     }
@@ -8904,9 +9498,9 @@ var Sphere = class _Sphere {
   get identity() {
     if (!this._identity) return null;
     return {
-      publicKey: this._identity.publicKey,
-      address: this._identity.address,
-      predicateAddress: this._identity.predicateAddress,
+      chainPubkey: this._identity.chainPubkey,
+      l1Address: this._identity.l1Address,
+      directAddress: this._identity.directAddress,
       ipnsName: this._identity.ipnsName,
       nametag: this._identity.nametag
     };
@@ -9023,7 +9617,7 @@ var Sphere = class _Sphere {
       if (this._masterKey) {
         address0 = this.deriveAddress(0).address;
       } else if (this._identity) {
-        address0 = this._identity.address;
+        address0 = this._identity.l1Address;
       }
     } catch {
     }
@@ -9070,8 +9664,8 @@ var Sphere = class _Sphere {
       } catch {
         if (i === 0 && this._identity) {
           addresses.push({
-            address: this._identity.address,
-            publicKey: this._identity.publicKey,
+            address: this._identity.l1Address,
+            publicKey: this._identity.chainPubkey,
             path: this.getDefaultAddressPath(),
             index: 0
           });
@@ -9150,7 +9744,7 @@ var Sphere = class _Sphere {
       } catch {
         if (i === 0 && this._identity) {
           addresses.push({
-            address: this._identity.address,
+            address: this._identity.l1Address,
             path: this.getDefaultAddressPath(),
             index: 0,
             isChange: false
@@ -9454,22 +10048,47 @@ var Sphere = class _Sphere {
     return this._currentAddressIndex;
   }
   /**
-   * Get nametag for a specific address index
+   * Get primary nametag for a specific address
    *
-   * @param index - Address index (default: current address)
-   * @returns Nametag or undefined if not registered
+   * @param addressId - Address identifier (DIRECT://xxx), defaults to current address
+   * @returns Primary nametag (index 0) or undefined if not registered
    */
-  getNametagForAddress(index) {
-    const addressIndex = index ?? this._currentAddressIndex;
-    return this._addressNametags.get(addressIndex);
+  getNametagForAddress(addressId) {
+    const id = addressId ?? this.getCurrentAddressId();
+    if (!id) return void 0;
+    const nametagsMap = this._addressNametags.get(id);
+    return nametagsMap?.get(0);
+  }
+  /**
+   * Get all nametags for a specific address
+   *
+   * @param addressId - Address identifier (DIRECT://xxx), defaults to current address
+   * @returns Map of nametagIndex to nametag, or undefined if no nametags
+   */
+  getNametagsForAddress(addressId) {
+    const id = addressId ?? this.getCurrentAddressId();
+    if (!id) return void 0;
+    const nametagsMap = this._addressNametags.get(id);
+    return nametagsMap ? new Map(nametagsMap) : void 0;
   }
   /**
    * Get all registered address nametags
    *
-   * @returns Map of address index to nametag
+   * @returns Map of addressId to (nametagIndex -> nametag)
    */
   getAllAddressNametags() {
-    return new Map(this._addressNametags);
+    const result = /* @__PURE__ */ new Map();
+    this._addressNametags.forEach((nametagsMap, addressId) => {
+      result.set(addressId, new Map(nametagsMap));
+    });
+    return result;
+  }
+  /**
+   * Get current address identifier (DIRECT://xxx format)
+   */
+  getCurrentAddressId() {
+    if (!this._identity?.directAddress) return void 0;
+    return getAddressId(this._identity.directAddress);
   }
   /**
    * Switch to a different address by index
@@ -9501,17 +10120,19 @@ var Sphere = class _Sphere {
     const addressInfo = this.deriveAddress(index, false);
     const ipnsHash = sha256(addressInfo.publicKey, "hex").slice(0, 40);
     const predicateAddress = await deriveL3PredicateAddress(addressInfo.privateKey);
-    const nametag = this._addressNametags.get(index);
+    const addressId = getAddressId(predicateAddress);
+    const nametagsMap = this._addressNametags.get(addressId);
+    const nametag = nametagsMap?.get(0);
     this._identity = {
       privateKey: addressInfo.privateKey,
-      publicKey: addressInfo.publicKey,
-      address: addressInfo.address,
-      predicateAddress,
+      chainPubkey: addressInfo.publicKey,
+      l1Address: addressInfo.address,
+      directAddress: predicateAddress,
       ipnsName: "12D3KooW" + ipnsHash,
       nametag
     };
     this._currentAddressIndex = index;
-    await this._storage.set(STORAGE_KEYS.CURRENT_ADDRESS_INDEX, index.toString());
+    await this._storage.set(STORAGE_KEYS_GLOBAL.CURRENT_ADDRESS_INDEX, index.toString());
     this._storage.setIdentity(this._identity);
     this._transport.setIdentity(this._identity);
     for (const provider of this._tokenStorageProviders.values()) {
@@ -9519,13 +10140,13 @@ var Sphere = class _Sphere {
     }
     await this.reinitializeModulesForNewAddress();
     this.emitEvent("identity:changed", {
-      address: this._identity.address,
-      predicateAddress: this._identity.predicateAddress,
-      publicKey: this._identity.publicKey,
+      l1Address: this._identity.l1Address,
+      directAddress: this._identity.directAddress,
+      chainPubkey: this._identity.chainPubkey,
       nametag: this._identity.nametag,
       addressIndex: index
     });
-    console.log(`[Sphere] Switched to address ${index}:`, this._identity.address);
+    console.log(`[Sphere] Switched to address ${index}:`, this._identity.l1Address);
   }
   /**
    * Re-initialize modules after address switch
@@ -9583,7 +10204,7 @@ var Sphere = class _Sphere {
     );
     return {
       ...info,
-      address: "alpha1" + info.address.slice(0, 38)
+      address: publicKeyToAddress(info.publicKey, "alpha")
     };
   }
   /**
@@ -9610,11 +10231,10 @@ var Sphere = class _Sphere {
       path
     );
     const publicKey = getPublicKey(derived.privateKey);
-    const addressHash = hash160(publicKey);
     return {
       privateKey: derived.privateKey,
       publicKey,
-      address: "alpha1" + addressHash.slice(0, 38),
+      address: publicKeyToAddress(publicKey, "alpha"),
       path,
       index
     };
@@ -9702,6 +10322,17 @@ var Sphere = class _Sphere {
   hasNametag() {
     return !!this._identity?.nametag;
   }
+  /**
+   * Get the PROXY address for the current nametag
+   * PROXY addresses are derived from the nametag hash and require
+   * the nametag token to claim funds sent to them
+   * @returns PROXY address string or undefined if no nametag
+   */
+  getProxyAddress() {
+    const nametag = this._identity?.nametag;
+    if (!nametag) return void 0;
+    return `PROXY:${hashNametag(nametag)}`;
+  }
   /**
    * Register a nametag for the current active address
    * Each address can have its own independent nametag
@@ -9730,14 +10361,25 @@ var Sphere = class _Sphere {
       throw new Error(`Nametag already registered for address ${this._currentAddressIndex}: @${this._identity.nametag}`);
     }
     if (this._transport.registerNametag) {
-      const success = await this._transport.registerNametag(cleanNametag, this._identity.publicKey);
+      const success = await this._transport.registerNametag(
+        cleanNametag,
+        this._identity.chainPubkey,
+        this._identity.directAddress || ""
+      );
       if (!success) {
         throw new Error("Failed to register nametag. It may already be taken.");
       }
     }
     this._identity.nametag = cleanNametag;
-    this._addressNametags.set(this._currentAddressIndex, cleanNametag);
-    await this._storage.set(STORAGE_KEYS.NAMETAG, cleanNametag);
+    const addressId = this.getCurrentAddressId();
+    if (addressId) {
+      let nametagsMap = this._addressNametags.get(addressId);
+      if (!nametagsMap) {
+        nametagsMap = /* @__PURE__ */ new Map();
+        this._addressNametags.set(addressId, nametagsMap);
+      }
+      nametagsMap.set(0, cleanNametag);
+    }
     await this.persistAddressNametags();
     if (!this._payments.hasNametag()) {
       console.log(`[Sphere] Minting nametag token for @${cleanNametag}...`);
@@ -9756,13 +10398,18 @@ var Sphere = class _Sphere {
   }
   /**
    * Persist address nametags to storage
+   * Format: { "DIRECT://abc...xyz": { "0": "alice", "1": "alice2" }, ... }
    */
   async persistAddressNametags() {
-    const nametagsObj = {};
-    this._addressNametags.forEach((nametag, index) => {
-      nametagsObj[index.toString()] = nametag;
+    const result = {};
+    this._addressNametags.forEach((nametagsMap, addressId) => {
+      const innerObj = {};
+      nametagsMap.forEach((nametag, index) => {
+        innerObj[index.toString()] = nametag;
+      });
+      result[addressId] = innerObj;
     });
-    await this._storage.set(STORAGE_KEYS.ADDRESS_NAMETAGS, JSON.stringify(nametagsObj));
+    await this._storage.set(STORAGE_KEYS_GLOBAL.ADDRESS_NAMETAGS, JSON.stringify(result));
   }
   /**
    * Mint a nametag token on-chain (like Sphere wallet and lottery)
@@ -9797,15 +10444,24 @@ var Sphere = class _Sphere {
   }
   /**
    * Load address nametags from storage
+   * Supports new format: { "DIRECT://abc...xyz": { "0": "alice" } }
+   * And legacy format: { "0": "alice" } (migrates to new format on save)
    */
   async loadAddressNametags() {
     try {
-      const saved = await this._storage.get(STORAGE_KEYS.ADDRESS_NAMETAGS);
+      const saved = await this._storage.get(STORAGE_KEYS_GLOBAL.ADDRESS_NAMETAGS);
       if (saved) {
-        const nametagsObj = JSON.parse(saved);
+        const parsed = JSON.parse(saved);
         this._addressNametags.clear();
-        for (const [indexStr, nametag] of Object.entries(nametagsObj)) {
-          this._addressNametags.set(parseInt(indexStr, 10), nametag);
+        for (const [key, value] of Object.entries(parsed)) {
+          if (typeof value === "object" && value !== null) {
+            const nametagsMap = /* @__PURE__ */ new Map();
+            for (const [indexStr, nametag] of Object.entries(value)) {
+              nametagsMap.set(parseInt(indexStr, 10), nametag);
+            }
+            this._addressNametags.set(key, nametagsMap);
+          } else if (typeof value === "string") {
+          }
         }
       }
     } catch {
@@ -9824,7 +10480,11 @@ var Sphere = class _Sphere {
       return;
     }
     try {
-      const success = await this._transport.registerNametag(nametag, this._identity.publicKey);
+      const success = await this._transport.registerNametag(
+        nametag,
+        this._identity.chainPubkey,
+        this._identity.directAddress || ""
+      );
       if (success) {
         console.log(`[Sphere] Nametag @${nametag} synced with Nostr`);
       } else {
@@ -9834,6 +10494,47 @@ var Sphere = class _Sphere {
       console.warn(`[Sphere] Nametag sync failed:`, error);
     }
   }
+  /**
+   * Recover nametag from Nostr after wallet import
+   * Searches for encrypted nametag events authored by this wallet's pubkey
+   * and decrypts them to restore the nametag association
+   */
+  async recoverNametagFromNostr() {
+    if (this._identity?.nametag) {
+      return;
+    }
+    if (!this._transport.recoverNametag) {
+      return;
+    }
+    try {
+      const recoveredNametag = await this._transport.recoverNametag();
+      if (recoveredNametag) {
+        if (this._identity) {
+          this._identity.nametag = recoveredNametag;
+        }
+        const addressId = this.getCurrentAddressId();
+        if (addressId) {
+          let nametagsMap = this._addressNametags.get(addressId);
+          if (!nametagsMap) {
+            nametagsMap = /* @__PURE__ */ new Map();
+            this._addressNametags.set(addressId, nametagsMap);
+          }
+          const nextIndex = nametagsMap.size;
+          nametagsMap.set(nextIndex, recoveredNametag);
+        }
+        await this.persistAddressNametags();
+        if (this._transport.registerNametag) {
+          await this._transport.registerNametag(
+            recoveredNametag,
+            this._identity.chainPubkey,
+            this._identity.directAddress || ""
+          );
+        }
+        this.emitEvent("nametag:recovered", { nametag: recoveredNametag });
+      }
+    } catch {
+    }
+  }
   /**
    * Validate nametag format
    */
@@ -9864,22 +10565,22 @@ var Sphere = class _Sphere {
   // ===========================================================================
   async storeMnemonic(mnemonic, derivationPath, basePath) {
     const encrypted = this.encrypt(mnemonic);
-    await this._storage.set(STORAGE_KEYS.MNEMONIC, encrypted);
+    await this._storage.set(STORAGE_KEYS_GLOBAL.MNEMONIC, encrypted);
     this._mnemonic = mnemonic;
     this._source = "mnemonic";
     this._derivationMode = "bip32";
     if (derivationPath) {
-      await this._storage.set(STORAGE_KEYS.DERIVATION_PATH, derivationPath);
+      await this._storage.set(STORAGE_KEYS_GLOBAL.DERIVATION_PATH, derivationPath);
     }
     const effectiveBasePath = basePath ?? DEFAULT_BASE_PATH;
     this._basePath = effectiveBasePath;
-    await this._storage.set(STORAGE_KEYS.BASE_PATH, effectiveBasePath);
-    await this._storage.set(STORAGE_KEYS.DERIVATION_MODE, this._derivationMode);
-    await this._storage.set(STORAGE_KEYS.WALLET_SOURCE, this._source);
+    await this._storage.set(STORAGE_KEYS_GLOBAL.BASE_PATH, effectiveBasePath);
+    await this._storage.set(STORAGE_KEYS_GLOBAL.DERIVATION_MODE, this._derivationMode);
+    await this._storage.set(STORAGE_KEYS_GLOBAL.WALLET_SOURCE, this._source);
   }
   async storeMasterKey(masterKey, chainCode, derivationPath, basePath, derivationMode) {
     const encrypted = this.encrypt(masterKey);
-    await this._storage.set(STORAGE_KEYS.MASTER_KEY, encrypted);
+    await this._storage.set(STORAGE_KEYS_GLOBAL.MASTER_KEY, encrypted);
     this._source = "file";
     this._mnemonic = null;
     if (derivationMode) {
@@ -9888,16 +10589,16 @@ var Sphere = class _Sphere {
       this._derivationMode = chainCode ? "bip32" : "wif_hmac";
     }
     if (chainCode) {
-      await this._storage.set(STORAGE_KEYS.CHAIN_CODE, chainCode);
+      await this._storage.set(STORAGE_KEYS_GLOBAL.CHAIN_CODE, chainCode);
     }
     if (derivationPath) {
-      await this._storage.set(STORAGE_KEYS.DERIVATION_PATH, derivationPath);
+      await this._storage.set(STORAGE_KEYS_GLOBAL.DERIVATION_PATH, derivationPath);
     }
     const effectiveBasePath = basePath ?? DEFAULT_BASE_PATH;
     this._basePath = effectiveBasePath;
-    await this._storage.set(STORAGE_KEYS.BASE_PATH, effectiveBasePath);
-    await this._storage.set(STORAGE_KEYS.DERIVATION_MODE, this._derivationMode);
-    await this._storage.set(STORAGE_KEYS.WALLET_SOURCE, this._source);
+    await this._storage.set(STORAGE_KEYS_GLOBAL.BASE_PATH, effectiveBasePath);
+    await this._storage.set(STORAGE_KEYS_GLOBAL.DERIVATION_MODE, this._derivationMode);
+    await this._storage.set(STORAGE_KEYS_GLOBAL.WALLET_SOURCE, this._source);
   }
   /**
    * Mark wallet as fully created (after successful initialization)
@@ -9905,20 +10606,20 @@ var Sphere = class _Sphere {
    * marked as existing after all initialization steps succeed.
    */
   async finalizeWalletCreation() {
-    await this._storage.set(STORAGE_KEYS.WALLET_EXISTS, "true");
+    await this._storage.set(STORAGE_KEYS_GLOBAL.WALLET_EXISTS, "true");
   }
   // ===========================================================================
   // Private: Identity Initialization
   // ===========================================================================
   async loadIdentityFromStorage() {
-    const encryptedMnemonic = await this._storage.get(STORAGE_KEYS.MNEMONIC);
-    const encryptedMasterKey = await this._storage.get(STORAGE_KEYS.MASTER_KEY);
-    const chainCode = await this._storage.get(STORAGE_KEYS.CHAIN_CODE);
-    const derivationPath = await this._storage.get(STORAGE_KEYS.DERIVATION_PATH);
-    const savedBasePath = await this._storage.get(STORAGE_KEYS.BASE_PATH);
-    const savedDerivationMode = await this._storage.get(STORAGE_KEYS.DERIVATION_MODE);
-    const savedSource = await this._storage.get(STORAGE_KEYS.WALLET_SOURCE);
-    const savedAddressIndex = await this._storage.get(STORAGE_KEYS.CURRENT_ADDRESS_INDEX);
+    const encryptedMnemonic = await this._storage.get(STORAGE_KEYS_GLOBAL.MNEMONIC);
+    const encryptedMasterKey = await this._storage.get(STORAGE_KEYS_GLOBAL.MASTER_KEY);
+    const chainCode = await this._storage.get(STORAGE_KEYS_GLOBAL.CHAIN_CODE);
+    const derivationPath = await this._storage.get(STORAGE_KEYS_GLOBAL.DERIVATION_PATH);
+    const savedBasePath = await this._storage.get(STORAGE_KEYS_GLOBAL.BASE_PATH);
+    const savedDerivationMode = await this._storage.get(STORAGE_KEYS_GLOBAL.DERIVATION_MODE);
+    const savedSource = await this._storage.get(STORAGE_KEYS_GLOBAL.WALLET_SOURCE);
+    const savedAddressIndex = await this._storage.get(STORAGE_KEYS_GLOBAL.CURRENT_ADDRESS_INDEX);
     this._basePath = savedBasePath ?? DEFAULT_BASE_PATH;
     this._derivationMode = savedDerivationMode ?? "bip32";
     this._source = savedSource ?? "unknown";
@@ -9952,65 +10653,60 @@ var Sphere = class _Sphere {
       this._storage.setIdentity(this._identity);
     }
     await this.loadAddressNametags();
-    const savedNametag = await this._storage.get(STORAGE_KEYS.NAMETAG);
     if (this._currentAddressIndex > 0 && this._masterKey) {
       const addressInfo = this.deriveAddress(this._currentAddressIndex, false);
       const ipnsHash = sha256(addressInfo.publicKey, "hex").slice(0, 40);
       const predicateAddress = await deriveL3PredicateAddress(addressInfo.privateKey);
-      const nametag = this._addressNametags.get(this._currentAddressIndex);
+      const addressId = getAddressId(predicateAddress);
+      const nametagsMap = this._addressNametags.get(addressId);
+      const nametag = nametagsMap?.get(0);
       this._identity = {
         privateKey: addressInfo.privateKey,
-        publicKey: addressInfo.publicKey,
-        address: addressInfo.address,
-        predicateAddress,
+        chainPubkey: addressInfo.publicKey,
+        l1Address: addressInfo.address,
+        directAddress: predicateAddress,
         ipnsName: "12D3KooW" + ipnsHash,
         nametag
       };
       this._storage.setIdentity(this._identity);
-      console.log(`[Sphere] Restored to address ${this._currentAddressIndex}:`, this._identity.address);
-    } else {
-      if (savedNametag && this._identity) {
-        this._identity.nametag = savedNametag;
-        if (!this._addressNametags.has(0)) {
-          this._addressNametags.set(0, savedNametag);
-        }
-        console.log("[Sphere] Restored nametag:", savedNametag);
-      } else if (this._identity) {
-        const nametag = this._addressNametags.get(0);
-        if (nametag) {
-          this._identity.nametag = nametag;
-          console.log("[Sphere] Restored nametag from map:", nametag);
-        }
+      console.log(`[Sphere] Restored to address ${this._currentAddressIndex}:`, this._identity.l1Address);
+    } else if (this._identity) {
+      const addressId = this.getCurrentAddressId();
+      const nametagsMap = addressId ? this._addressNametags.get(addressId) : void 0;
+      const nametag = nametagsMap?.get(0);
+      if (nametag) {
+        this._identity.nametag = nametag;
       }
     }
   }
   async initializeIdentityFromMnemonic(mnemonic, derivationPath) {
-    const path = derivationPath ?? DEFAULT_DERIVATION_PATH;
+    const basePath = derivationPath ?? DEFAULT_BASE_PATH;
+    const fullPath = `${basePath}/0/0`;
     const masterKey = identityFromMnemonicSync(mnemonic);
     const derivedKey = deriveKeyAtPath$1(
       masterKey.privateKey,
       masterKey.chainCode,
-      `${path}/0/0`
+      fullPath
     );
     const publicKey = getPublicKey(derivedKey.privateKey);
-    const addressHash = hash160(publicKey);
+    const address = publicKeyToAddress(publicKey, "alpha");
     const ipnsHash = sha256(publicKey, "hex").slice(0, 40);
     const predicateAddress = await deriveL3PredicateAddress(derivedKey.privateKey);
     this._identity = {
       privateKey: derivedKey.privateKey,
-      publicKey,
-      address: "alpha1" + addressHash.slice(0, 38),
-      predicateAddress,
+      chainPubkey: publicKey,
+      l1Address: address,
+      directAddress: predicateAddress,
       ipnsName: "12D3KooW" + ipnsHash
     };
     this._masterKey = masterKey;
-    console.log("[Sphere] Identity initialized from mnemonic, path:", path);
   }
   async initializeIdentityFromMasterKey(masterKey, chainCode, derivationPath) {
-    const path = derivationPath ?? DEFAULT_DERIVATION_PATH;
+    const basePath = derivationPath ?? DEFAULT_BASE_PATH;
+    const fullPath = `${basePath}/0/0`;
     let privateKey;
     if (chainCode) {
-      const derivedKey = deriveKeyAtPath$1(masterKey, chainCode, `${path}/0/0`);
+      const derivedKey = deriveKeyAtPath$1(masterKey, chainCode, fullPath);
       privateKey = derivedKey.privateKey;
       this._masterKey = {
         privateKey: masterKey,
@@ -10021,17 +10717,16 @@ var Sphere = class _Sphere {
       this._masterKey = null;
     }
     const publicKey = getPublicKey(privateKey);
-    const addressHash = hash160(publicKey);
+    const address = publicKeyToAddress(publicKey, "alpha");
     const ipnsHash = sha256(publicKey, "hex").slice(0, 40);
     const predicateAddress = await deriveL3PredicateAddress(privateKey);
     this._identity = {
       privateKey,
-      publicKey,
-      address: "alpha1" + addressHash.slice(0, 38),
-      predicateAddress,
+      chainPubkey: publicKey,
+      l1Address: address,
+      directAddress: predicateAddress,
       ipnsName: "12D3KooW" + ipnsHash
     };
-    console.log("[Sphere] Identity initialized from master key, path:", path, "chainCode:", !!chainCode);
   }
   // ===========================================================================
   // Private: Provider & Module Initialization
@@ -10526,4 +11221,201 @@ declare namespace index {
   export { type index_BlockHeader as BlockHeader, CHARSET$1 as CHARSET, type index_ClassificationResult as ClassificationResult, type index_ClassifiedUTXO as ClassifiedUTXO, type index_ExportOptions as ExportOptions, type index_RestoreWalletResult as RestoreWalletResult, type index_StoredWallet as StoredWallet, type index_Transaction as Transaction, type index_TransactionDetail as TransactionDetail, type index_TransactionHistoryItem as TransactionHistoryItem, type index_TransactionInput as TransactionInput, type index_TransactionOutput as TransactionOutput, type index_TransactionPlan as TransactionPlan, type index_UTXO as UTXO, index_VESTING_THRESHOLD as VESTING_THRESHOLD, type index_VestingBalances as VestingBalances, type index_VestingMode as VestingMode, type index_Wallet as Wallet, type index_WalletAddress as WalletAddress, index_WalletAddressHelper as WalletAddressHelper, type index_WalletJSON as WalletJSON, type index_WalletJSONAddress as WalletJSONAddress, type index_WalletJSONDerivationMode as WalletJSONDerivationMode, type index_WalletJSONExportOptions as WalletJSONExportOptions, type index_WalletJSONImportResult as WalletJSONImportResult, type index_WalletJSONSource as WalletJSONSource, addressToScriptHash$1 as addressToScriptHash, index_broadcast as broadcast, index_buildSegWitTransaction as buildSegWitTransaction, index_collectUtxosForAmount as collectUtxosForAmount, computeHash160$1 as computeHash160, index_connect as connect, convertBits$1 as convertBits, index_createAndSignTransaction as createAndSignTransaction, createBech32$1 as createBech32, index_createScriptPubKey as createScriptPubKey, index_createTransactionPlan as createTransactionPlan, decodeBech32$1 as decodeBech32, decrypt$1 as decrypt, decryptWallet$1 as decryptWallet, index_deriveChildKey as deriveChildKey, index_deriveChildKeyBIP32 as deriveChildKeyBIP32, index_deriveKeyAtPath as deriveKeyAtPath, index_disconnect as disconnect, domIdToPath$1 as domIdToPath, ec$1 as ec, encodeBech32$1 as encodeBech32, encrypt$1 as encrypt, encryptWallet$1 as encryptWallet, index_generateAddressFromMasterKey as generateAddressFromMasterKey, generateAddressInfo$1 as generateAddressInfo, index_generateHDAddress as generateHDAddress, index_generateHDAddressBIP32 as generateHDAddressBIP32, index_generateMasterKeyFromSeed as generateMasterKeyFromSeed, generatePrivateKey$1 as generatePrivateKey, index_getBalance as getBalance, index_getBlockHeader as getBlockHeader, index_getCurrentBlockHeight as getCurrentBlockHeight, getIndexFromPath$1 as getIndexFromPath, index_getTransaction as getTransaction, index_getTransactionHistory as getTransactionHistory, index_getUtxo as getUtxo, hash160$1 as hash160, hash160ToBytes$1 as hash160ToBytes, hexToWIF$1 as hexToWIF, isChangePath$1 as isChangePath, index_isWebSocketConnected as isWebSocketConnected, parsePathComponents$1 as parsePathComponents, pathToDOMId$1 as pathToDOMId, privateKeyToAddressInfo$1 as privateKeyToAddressInfo, publicKeyToAddress$1 as publicKeyToAddress, index_rpc as rpc, index_sendAlpha as sendAlpha, index_subscribeBlocks as subscribeBlocks, index_vestingClassifier as vestingClassifier, index_vestingState as vestingState, index_waitForConnection as waitForConnection };
 }
 
-export { type AddressInfo, type AggregatorClient, type AggregatorEvent, type AggregatorEventCallback, type AggregatorEventType, type AggregatorProvider, type AggregatorProviderConfig, type BaseProvider, type BroadcastHandler, type BroadcastMessage, type CMasterKeyData, COIN_TYPES, CommunicationsModule$1 as CommunicationsModule, type CommunicationsModuleConfig, type CommunicationsModuleDependencies, DEFAULT_AGGREGATOR_TIMEOUT, DEFAULT_AGGREGATOR_URL, DEFAULT_DERIVATION_PATH$1 as DEFAULT_DERIVATION_PATH, DEFAULT_ELECTRUM_URL, DEFAULT_IPFS_BOOTSTRAP_PEERS, DEFAULT_IPFS_GATEWAYS, DEFAULT_NOSTR_RELAYS, DEV_AGGREGATOR_URL, type DecryptionProgressCallback, type DerivationMode, type DirectMessage, type ExtendedValidationResult, type FullIdentity, type Identity, type IdentityConfig, type InclusionProof, type IncomingBroadcast, type IncomingMessage, type IncomingPaymentRequest$1 as IncomingPaymentRequest, type IncomingTokenTransfer, type IncomingTransfer, type InvalidatedNametagEntry, index as L1, type L1Balance, L1PaymentsModule$1 as L1PaymentsModule, type L1PaymentsModuleConfig, type L1PaymentsModuleDependencies, type L1SendRequest, type L1SendResult, type L1Transaction, type L1Utxo, LIMITS$1 as LIMITS, type LegacyFileImportOptions, type LegacyFileInfo, type LegacyFileParseResult, type LegacyFileParsedData, type LegacyFileType, type LoadResult, type LoggingConfig, type MessageHandler, type MintOutboxEntry, type MintParams, type MintResult, NETWORKS, NOSTR_EVENT_KINDS, type NametagData, type NetworkType, type OracleEvent, type OracleEventCallback, type OracleEventType, type OracleProvider, type OutboxEntry, type OutgoingPaymentRequest, type ParsedStorageData, type PaymentRequest, type PaymentRequestHandler$1 as PaymentRequestHandler, type PaymentRequestResponse, type PaymentRequestResponseHandler$1 as PaymentRequestResponseHandler, type PaymentRequestResponseType$1 as PaymentRequestResponseType, type PaymentRequestResult, type PaymentRequestStatus, PaymentsModule$1 as PaymentsModule, type PaymentsModuleConfig, type PaymentsModuleDependencies, type ProviderMetadata, type ProviderStatus, STORAGE_KEYS$1 as STORAGE_KEYS, STORAGE_PREFIX$1 as STORAGE_PREFIX, type SaveResult, type SpentTokenInfo, type SpentTokenResult, Sphere$1 as Sphere, type SphereConfig, type SphereCreateOptions, SphereError, type SphereErrorCode, type SphereEventHandler, type SphereEventMap, type SphereEventType, type SphereInitOptions, type SphereInitResult, type SphereLoadOptions, type StorageEvent, type StorageEventCallback, type StorageEventType, type StorageProvider, type StorageProviderConfig, type SubmitResult, type SyncResult, TEST_AGGREGATOR_URL, TEST_ELECTRUM_URL, TEST_NOSTR_RELAYS, TIMEOUTS, type Token, type TokenBalance, type TokenState, type TokenStatus, type TokenStorageProvider, type TokenTransferHandler, type TokenTransferPayload, type ValidationResult as TokenValidationResult, TokenValidator, type TombstoneEntry, type TransferCommitment, type TransferRequest, type TransferResult, type TransferStatus, type TransportEvent, type TransportEventCallback, type TransportEventType, type TransportProvider, type TransportProviderConfig, type TrustBaseLoader, type TxfAuthenticator, type TxfGenesis, type TxfGenesisData, type TxfInclusionProof, type TxfIntegrity, type TxfInvalidEntry, type TxfMerkleStep, type TxfMerkleTreePath, type TxfMeta, type TxfOutboxEntry, type TxfSentEntry, type TxfState, type TxfStorageData, type TxfStorageDataBase, type TxfToken, type TxfTombstone, type TxfTransaction, type ValidationAction, type ValidationIssue, type ValidationResult$1 as ValidationResult, type WaitOptions, type WalletDatInfo, type WalletInfo, type WalletJSON$1 as WalletJSON, type WalletJSONExportOptions$1 as WalletJSONExportOptions, type WalletSource, archivedKeyFromTokenId$1 as archivedKeyFromTokenId, base58Decode$1 as base58Decode, base58Encode$1 as base58Encode, buildTxfStorageData$1 as buildTxfStorageData, bytesToHex$1 as bytesToHex, countCommittedTransactions, createAddress, createCommunicationsModule$1 as createCommunicationsModule, createKeyPair, createL1PaymentsModule, createPaymentsModule$1 as createPaymentsModule, createSphere, createTokenValidator, decodeBech32$1 as decodeBech32, decryptCMasterKey$1 as decryptCMasterKey, decryptPrivateKey$1 as decryptPrivateKey, decryptTextFormatKey$1 as decryptTextFormatKey, deriveAddressInfo$1 as deriveAddressInfo, deriveChildKey$2 as deriveChildKey, deriveKeyAtPath$2 as deriveKeyAtPath, doubleSha256, encodeBech32$1 as encodeBech32, extractFromText$1 as extractFromText, findPattern$1 as findPattern, forkedKeyFromTokenIdAndState$1 as forkedKeyFromTokenIdAndState, formatAmount, generateMasterKey$1 as generateMasterKey, generateMnemonic, getAddressHrp, getCurrentStateHash$1 as getCurrentStateHash, getPublicKey$1 as getPublicKey, getSphere, getTokenId, hasMissingNewStateHash, hasUncommittedTransactions, hasValidTxfData, hash160$1 as hash160, hexToBytes, identityFromMnemonicSync$1 as identityFromMnemonicSync, initSphere, isArchivedKey$1 as isArchivedKey, isForkedKey$1 as isForkedKey, isSQLiteDatabase$1 as isSQLiteDatabase, isTextWalletEncrypted$1 as isTextWalletEncrypted, isTokenKey$1 as isTokenKey, isValidBech32, isValidPrivateKey$1 as isValidPrivateKey, isValidTokenId, isWalletDatEncrypted$1 as isWalletDatEncrypted, isWalletTextFormat$1 as isWalletTextFormat, keyFromTokenId$1 as keyFromTokenId, loadSphere, mnemonicToSeedSync, normalizeSdkTokenToStorage$1 as normalizeSdkTokenToStorage, objectToTxf, parseAndDecryptWalletDat$1 as parseAndDecryptWalletDat, parseAndDecryptWalletText$1 as parseAndDecryptWalletText, parseForkedKey$1 as parseForkedKey, parseTxfStorageData$1 as parseTxfStorageData, parseWalletDat$1 as parseWalletDat, parseWalletText$1 as parseWalletText, randomBytes, randomHex, randomUUID, ripemd160$1 as ripemd160, sha256$1 as sha256, sleep, sphereExists, toHumanReadable, toSmallestUnit, tokenIdFromArchivedKey$1 as tokenIdFromArchivedKey, tokenIdFromKey$1 as tokenIdFromKey, tokenToTxf$1 as tokenToTxf, txfToToken$1 as txfToToken, validateMnemonic };
+/**
+ * Token Registry
+ *
+ * Provides token definitions (metadata) for known tokens on the Unicity network.
+ * Uses bundled static data for offline access and consistency.
+ */
+/**
+ * Icon entry for token
+ */
+interface TokenIcon {
+    url: string;
+}
+/**
+ * Token definition with full metadata
+ */
+interface TokenDefinition {
+    /** Network identifier (e.g., "unicity:testnet") */
+    network: string;
+    /** Asset kind - fungible or non-fungible */
+    assetKind: 'fungible' | 'non-fungible';
+    /** Token name (e.g., "bitcoin", "ethereum") */
+    name: string;
+    /** Token symbol (e.g., "BTC", "ETH") - only for fungible tokens */
+    symbol?: string;
+    /** Decimal places for display - only for fungible tokens */
+    decimals?: number;
+    /** Human-readable description */
+    description: string;
+    /** Icon URLs array */
+    icons?: TokenIcon[];
+    /** Hex-encoded coin ID (64 characters) */
+    id: string;
+}
+/**
+ * Network type for registry lookup
+ */
+type RegistryNetwork = 'testnet' | 'mainnet' | 'dev';
+/**
+ * Token Registry service
+ *
+ * Provides lookup functionality for token definitions by coin ID.
+ * Uses singleton pattern for efficient memory usage.
+ *
+ * @example
+ * ```ts
+ * import { TokenRegistry } from '@unicitylabs/sphere-sdk';
+ *
+ * const registry = TokenRegistry.getInstance();
+ * const def = registry.getDefinition('455ad8720656b08e8dbd5bac1f3c73eeea5431565f6c1c3af742b1aa12d41d89');
+ * console.log(def?.symbol); // 'UCT'
+ * ```
+ */
+declare class TokenRegistry {
+    private static instance;
+    private readonly definitionsById;
+    private readonly definitionsBySymbol;
+    private readonly definitionsByName;
+    private constructor();
+    /**
+     * Get singleton instance of TokenRegistry
+     */
+    static getInstance(): TokenRegistry;
+    /**
+     * Reset the singleton instance (useful for testing)
+     */
+    static resetInstance(): void;
+    /**
+     * Load registry data from bundled JSON
+     */
+    private loadRegistry;
+    /**
+     * Get token definition by hex coin ID
+     * @param coinId - 64-character hex string
+     * @returns Token definition or undefined if not found
+     */
+    getDefinition(coinId: string): TokenDefinition | undefined;
+    /**
+     * Get token definition by symbol (e.g., "UCT", "BTC")
+     * @param symbol - Token symbol (case-insensitive)
+     * @returns Token definition or undefined if not found
+     */
+    getDefinitionBySymbol(symbol: string): TokenDefinition | undefined;
+    /**
+     * Get token definition by name (e.g., "bitcoin", "ethereum")
+     * @param name - Token name (case-insensitive)
+     * @returns Token definition or undefined if not found
+     */
+    getDefinitionByName(name: string): TokenDefinition | undefined;
+    /**
+     * Get token symbol for a coin ID
+     * @param coinId - 64-character hex string
+     * @returns Symbol (e.g., "UCT") or truncated ID if not found
+     */
+    getSymbol(coinId: string): string;
+    /**
+     * Get token name for a coin ID
+     * @param coinId - 64-character hex string
+     * @returns Name (e.g., "Bitcoin") or coin ID if not found
+     */
+    getName(coinId: string): string;
+    /**
+     * Get decimal places for a coin ID
+     * @param coinId - 64-character hex string
+     * @returns Decimals or 0 if not found
+     */
+    getDecimals(coinId: string): number;
+    /**
+     * Get icon URL for a coin ID
+     * @param coinId - 64-character hex string
+     * @param preferPng - Prefer PNG format over SVG
+     * @returns Icon URL or null if not found
+     */
+    getIconUrl(coinId: string, preferPng?: boolean): string | null;
+    /**
+     * Check if a coin ID is known in the registry
+     * @param coinId - 64-character hex string
+     * @returns true if the coin is in the registry
+     */
+    isKnown(coinId: string): boolean;
+    /**
+     * Get all token definitions
+     * @returns Array of all token definitions
+     */
+    getAllDefinitions(): TokenDefinition[];
+    /**
+     * Get all fungible token definitions
+     * @returns Array of fungible token definitions
+     */
+    getFungibleTokens(): TokenDefinition[];
+    /**
+     * Get all non-fungible token definitions
+     * @returns Array of non-fungible token definitions
+     */
+    getNonFungibleTokens(): TokenDefinition[];
+    /**
+     * Get coin ID by symbol
+     * @param symbol - Token symbol (e.g., "UCT")
+     * @returns Coin ID hex string or undefined if not found
+     */
+    getCoinIdBySymbol(symbol: string): string | undefined;
+    /**
+     * Get coin ID by name
+     * @param name - Token name (e.g., "bitcoin")
+     * @returns Coin ID hex string or undefined if not found
+     */
+    getCoinIdByName(name: string): string | undefined;
+}
+/**
+ * Get token definition by coin ID
+ * @param coinId - 64-character hex string
+ * @returns Token definition or undefined
+ */
+declare function getTokenDefinition(coinId: string): TokenDefinition | undefined;
+/**
+ * Get token symbol by coin ID
+ * @param coinId - 64-character hex string
+ * @returns Symbol or truncated ID
+ */
+declare function getTokenSymbol(coinId: string): string;
+/**
+ * Get token name by coin ID
+ * @param coinId - 64-character hex string
+ * @returns Name or coin ID
+ */
+declare function getTokenName(coinId: string): string;
+/**
+ * Get token decimals by coin ID
+ * @param coinId - 64-character hex string
+ * @returns Decimals or 0
+ */
+declare function getTokenDecimals(coinId: string): number;
+/**
+ * Get token icon URL by coin ID
+ * @param coinId - 64-character hex string
+ * @param preferPng - Prefer PNG over SVG
+ * @returns Icon URL or null
+ */
+declare function getTokenIconUrl(coinId: string, preferPng?: boolean): string | null;
+/**
+ * Check if coin ID is in registry
+ * @param coinId - 64-character hex string
+ * @returns true if known
+ */
+declare function isKnownToken(coinId: string): boolean;
+/**
+ * Get coin ID by symbol
+ * @param symbol - Token symbol (e.g., "UCT")
+ * @returns Coin ID or undefined
+ */
+declare function getCoinIdBySymbol(symbol: string): string | undefined;
+/**
+ * Get coin ID by name
+ * @param name - Token name (e.g., "bitcoin")
+ * @returns Coin ID or undefined
+ */
+declare function getCoinIdByName(name: string): string | undefined;
+
+export { type AddressInfo, type AggregatorClient, type AggregatorEvent, type AggregatorEventCallback, type AggregatorEventType, type AggregatorProvider, type AggregatorProviderConfig, type BaseProvider, type BroadcastHandler, type BroadcastMessage, type CMasterKeyData, COIN_TYPES, CommunicationsModule$1 as CommunicationsModule, type CommunicationsModuleConfig, type CommunicationsModuleDependencies, DEFAULT_AGGREGATOR_TIMEOUT, DEFAULT_AGGREGATOR_URL, DEFAULT_DERIVATION_PATH, DEFAULT_ELECTRUM_URL, DEFAULT_IPFS_BOOTSTRAP_PEERS, DEFAULT_IPFS_GATEWAYS, DEFAULT_NOSTR_RELAYS, DEV_AGGREGATOR_URL, type DecryptionProgressCallback, type DerivationMode, type DirectMessage, type ExtendedValidationResult, type FullIdentity, type Identity, type IdentityConfig, type InclusionProof, type IncomingBroadcast, type IncomingMessage, type IncomingPaymentRequest$1 as IncomingPaymentRequest, type IncomingTokenTransfer, type IncomingTransfer, type InvalidatedNametagEntry, index as L1, type L1Balance, L1PaymentsModule$1 as L1PaymentsModule, type L1PaymentsModuleConfig, type L1PaymentsModuleDependencies, type L1SendRequest, type L1SendResult, type L1Transaction, type L1Utxo, LIMITS$1 as LIMITS, type LegacyFileImportOptions, type LegacyFileInfo, type LegacyFileParseResult, type LegacyFileParsedData, type LegacyFileType, type LoadResult, type LoggingConfig, type MessageHandler, type MintOutboxEntry, type MintParams, type MintResult, NETWORKS, NOSTR_EVENT_KINDS, type NametagData, type NetworkType, type OracleEvent, type OracleEventCallback, type OracleEventType, type OracleProvider, type OutboxEntry, type OutgoingPaymentRequest, type ParsedStorageData, type PaymentRequest, type PaymentRequestHandler$1 as PaymentRequestHandler, type PaymentRequestResponse, type PaymentRequestResponseHandler$1 as PaymentRequestResponseHandler, type PaymentRequestResponseType$1 as PaymentRequestResponseType, type PaymentRequestResult, type PaymentRequestStatus, PaymentsModule$1 as PaymentsModule, type PaymentsModuleConfig, type PaymentsModuleDependencies, type ProviderMetadata, type ProviderStatus, type RegistryNetwork, STORAGE_KEYS, STORAGE_PREFIX, type SaveResult, type SpentTokenInfo, type SpentTokenResult, Sphere$1 as Sphere, type SphereConfig, type SphereCreateOptions, SphereError, type SphereErrorCode, type SphereEventHandler, type SphereEventMap, type SphereEventType, type SphereInitOptions, type SphereInitResult, type SphereLoadOptions, type StorageEvent, type StorageEventCallback, type StorageEventType, type StorageProvider, type StorageProviderConfig, type SubmitResult, type SyncResult, TEST_AGGREGATOR_URL, TEST_ELECTRUM_URL, TEST_NOSTR_RELAYS, TIMEOUTS, type Token, type TokenBalance, type TokenDefinition, type TokenIcon, TokenRegistry, type TokenState, type TokenStatus, type TokenStorageProvider, type TokenTransferHandler, type TokenTransferPayload, type ValidationResult as TokenValidationResult, TokenValidator, type TombstoneEntry, type TransferCommitment, type TransferRequest, type TransferResult, type TransferStatus, type TransportEvent, type TransportEventCallback, type TransportEventType, type TransportProvider, type TransportProviderConfig, type TrustBaseLoader, type TxfAuthenticator, type TxfGenesis, type TxfGenesisData, type TxfInclusionProof, type TxfIntegrity, type TxfInvalidEntry, type TxfMerkleStep, type TxfMerkleTreePath, type TxfMeta, type TxfOutboxEntry, type TxfSentEntry, type TxfState, type TxfStorageData, type TxfStorageDataBase, type TxfToken, type TxfTombstone, type TxfTransaction, type ValidationAction, type ValidationIssue, type ValidationResult$1 as ValidationResult, type WaitOptions, type WalletDatInfo, type WalletInfo, type WalletJSON$1 as WalletJSON, type WalletJSONExportOptions$1 as WalletJSONExportOptions, type WalletSource, archivedKeyFromTokenId$1 as archivedKeyFromTokenId, base58Decode$1 as base58Decode, base58Encode$1 as base58Encode, buildTxfStorageData$1 as buildTxfStorageData, bytesToHex$1 as bytesToHex, countCommittedTransactions, createAddress, createCommunicationsModule$1 as createCommunicationsModule, createKeyPair, createL1PaymentsModule, createPaymentsModule$1 as createPaymentsModule, createSphere, createTokenValidator, decodeBech32$1 as decodeBech32, decryptCMasterKey$1 as decryptCMasterKey, decryptPrivateKey$1 as decryptPrivateKey, decryptTextFormatKey$1 as decryptTextFormatKey, deriveAddressInfo$1 as deriveAddressInfo, deriveChildKey$2 as deriveChildKey, deriveKeyAtPath$2 as deriveKeyAtPath, doubleSha256, encodeBech32$1 as encodeBech32, extractFromText$1 as extractFromText, findPattern$1 as findPattern, forkedKeyFromTokenIdAndState$1 as forkedKeyFromTokenIdAndState, formatAmount, generateMasterKey$1 as generateMasterKey, generateMnemonic, getAddressHrp, getCoinIdByName, getCoinIdBySymbol, getCurrentStateHash$1 as getCurrentStateHash, getPublicKey$1 as getPublicKey, getSphere, getTokenDecimals, getTokenDefinition, getTokenIconUrl, getTokenId, getTokenName, getTokenSymbol, hasMissingNewStateHash, hasUncommittedTransactions, hasValidTxfData, hash160$1 as hash160, hexToBytes, identityFromMnemonicSync$1 as identityFromMnemonicSync, initSphere, isArchivedKey$1 as isArchivedKey, isForkedKey$1 as isForkedKey, isKnownToken, isSQLiteDatabase$1 as isSQLiteDatabase, isTextWalletEncrypted$1 as isTextWalletEncrypted, isTokenKey$1 as isTokenKey, isValidBech32, isValidPrivateKey$1 as isValidPrivateKey, isValidTokenId, isWalletDatEncrypted$1 as isWalletDatEncrypted, isWalletTextFormat$1 as isWalletTextFormat, keyFromTokenId$1 as keyFromTokenId, loadSphere, mnemonicToSeedSync, normalizeSdkTokenToStorage$1 as normalizeSdkTokenToStorage, objectToTxf, parseAndDecryptWalletDat$1 as parseAndDecryptWalletDat, parseAndDecryptWalletText$1 as parseAndDecryptWalletText, parseForkedKey$1 as parseForkedKey, parseTxfStorageData$1 as parseTxfStorageData, parseWalletDat$1 as parseWalletDat, parseWalletText$1 as parseWalletText, randomBytes, randomHex, randomUUID, ripemd160$1 as ripemd160, sha256$1 as sha256, sleep, sphereExists, toHumanReadable, toSmallestUnit, tokenIdFromArchivedKey$1 as tokenIdFromArchivedKey, tokenIdFromKey$1 as tokenIdFromKey, tokenToTxf$1 as tokenToTxf, txfToToken$1 as txfToToken, validateMnemonic };