@zubari/sdk 0.2.3 → 0.2.5

package/dist/services/index.d.mts

@@ -1,579 +1,303 @@
-import { o as SwapQuote, b as TxResult, N as NetworkType } from '../index-Bou-9cAG.mjs';
+export { B as BrowserAddressDerivation, C as BrowserChainAddress, a as BrowserMultiChainAddresses, l as ChainAddress, m as ChainBalance, D as DeriveAddressResponse, c as DeriveAllAddressesResponse, v as FeeEstimate, F as FeeRates, G as GenerateSeedResponse, M as MultiChainAddresses, e as SendTransactionResponse, k as SupportedChain, S as SwapService, u as TransactionHistoryItem, d as TransactionHistoryResponse, s as TransactionParams, t as TransactionResult, p as TransactionService, w as TransactionServiceConfig, f as TransactionStatusResponse, V as ValidateSeedResponse, W as WdkApiClient, b as WdkApiConfig, T as WdkTransactionHistoryItem, n as WdkTransactionResult, Z as ZubariWdkService, o as ZubariWdkServiceConfig, r as createTransactionService, i as createZubariWdkService, q as getTransactionService, g as getWdkApiClient, h as getZubariWdkService, j as isBrowser } from '../TransactionService-8xSEGoWA.mjs';
+import { N as NFTCurrency } from '../index-Cx389p_j.mjs';
 
 /**
- * SwapService - DEX integration via Velora
+ * Zubari API Client
  *
- * Handles token swaps with slippage protection,
- * quote fetching, and earnings conversion.
- */
-declare class SwapService {
-    private readonly _chainId;
-    private readonly isTestnet;
-    constructor(chainId: number, isTestnet?: boolean);
-    /**
-     * Get a swap quote
-     */
-    getQuote(tokenIn: string, tokenOut: string, amountIn: bigint): Promise<SwapQuote>;
-    /**
-     * Execute a swap with slippage protection
-     */
-    executeSwap(quote: SwapQuote, slippageToleranceBps?: number): Promise<TxResult>;
-    /**
-     * Convert earnings to USDT, keeping some ETH for gas
-     */
-    convertEarningsToStable(ethBalance: bigint, reserveForGas?: bigint): Promise<TxResult>;
-    /**
-     * Check if a swap route exists
-     */
-    hasRoute(tokenIn: string, tokenOut: string): Promise<boolean>;
-    /**
-     * Get supported tokens for swapping
-     */
-    getSupportedTokens(): Promise<string[]>;
-}
-
-/**
- * WDK API Client
- *
- * Client for calling the backend WDK endpoints to derive addresses
- * using Tether WDK (which runs server-side in Node.js).
+ * Comprehensive client for interacting with the Zubari backend API.
+ * Includes NFT, Marketplace, Tips, and Subscription operations.
  */
 
-interface WdkApiConfig {
+interface ZubariApiConfig {
     baseUrl: string;
     timeout?: number;
+    authToken?: string;
 }
-interface DeriveAddressResponse {
-    success: boolean;
-    address?: string;
-    chain?: string;
-    path?: string;
-    network?: string;
-    error?: string;
+interface NFTVoucher {
+    tokenId: string;
+    uri: string;
+    creator: string;
+    royaltyBps: number;
+    deadline: number;
+    signature: string;
+    price: string;
+    currency: string;
+    nonce: number;
+    contentHash?: string;
+    userId?: string;
+    watermarkTimestamp?: number;
+    sessionId?: string;
+}
+interface CreateVoucherRequest {
+    creatorAddress: string;
+    price: string;
+    currency: NFTCurrency;
 }
-interface DeriveAllAddressesResponse {
+interface CreateVoucherResponse {
     success: boolean;
-    addresses?: {
-        ethereum: string | null;
-        bitcoin: string | null;
-        ton: string | null;
-        tron: string | null;
-        solana: string | null;
-        spark: string | null;
-    };
-    network?: string;
+    voucher?: NFTVoucher;
+    signature?: string;
+    nftId?: string;
     error?: string;
 }
-interface ValidateSeedResponse {
+interface RedeemVoucherRequest {
+    buyerAddress: string;
+    paymentTxHash?: string;
+}
+interface RedeemVoucherResponse {
     success: boolean;
-    isValid?: boolean;
-    wordCount?: number;
+    transactionHash?: string;
+    tokenId?: string;
+    owner?: string;
+    nftId?: string;
     error?: string;
 }
-interface GenerateSeedResponse {
+interface VoucherStatusResponse {
     success: boolean;
-    seed?: string;
-    wordCount?: number;
+    nftId?: string;
+    hasVoucher?: boolean;
+    isRedeemed?: boolean;
+    voucher?: NFTVoucher;
     error?: string;
 }
-interface TransactionHistoryItem$1 {
-    hash: string;
-    from: string;
-    to: string;
-    value: string;
-    timestamp: number;
-    status: 'confirmed' | 'pending' | 'failed';
-    blockNumber?: number;
+interface NFTResponse {
+    id: string;
+    tokenId?: string;
+    contractAddress?: string;
+    name: string;
+    description?: string;
+    imageUrl?: string;
+    animationUrl?: string;
+    externalUrl?: string;
+    attributes?: Array<{
+        trait_type: string;
+        value: string | number;
+    }>;
+    creatorId: string;
+    ownerId: string;
+    price?: string;
+    currency?: string;
+    royaltyBps: number;
+    isLazyMinted: boolean;
+    isMinted: boolean;
+    mintedAt?: string;
+    transactionHash?: string;
+    createdAt: string;
+    updatedAt: string;
 }
-interface TransactionHistoryResponse {
-    success: boolean;
-    address?: string;
-    transactions?: TransactionHistoryItem$1[];
-    chain?: string;
-    network?: string;
-    error?: string;
+interface CreateNFTRequest {
+    name: string;
+    description?: string;
+    price: string;
+    currency: NFTCurrency;
+    royaltyBps?: number;
+    attributes?: Array<{
+        trait_type: string;
+        value: string | number;
+    }>;
+    externalUrl?: string;
 }
-interface SendTransactionResponse {
+interface NFTListResponse {
     success: boolean;
-    txHash?: string;
-    from?: string;
-    to?: string;
-    amount?: string;
-    chain?: string;
-    network?: string;
+    nfts?: NFTResponse[];
+    pagination?: {
+        page: number;
+        limit: number;
+        total: number;
+        pages: number;
+    };
     error?: string;
 }
-interface TransactionStatusResponse {
+interface MarketListing {
+    id: string;
+    nftId: string;
+    nft?: NFTResponse;
+    sellerId: string;
+    sellerAddress: string;
+    price: string;
+    currency: string;
+    expiresAt: string;
+    status: 'ACTIVE' | 'SOLD' | 'CANCELLED' | 'EXPIRED';
+    transactionHash?: string;
+    createdAt: string;
+    updatedAt: string;
+}
+interface ListItemRequest {
+    nftId: string;
+    price: string;
+    currency: NFTCurrency;
+    duration?: number;
+}
+interface ListItemResponse {
     success: boolean;
-    hash?: string;
-    status?: 'confirmed' | 'pending' | 'failed';
-    blockNumber?: number;
-    confirmations?: number;
-    timestamp?: number;
-    from?: string;
-    to?: string;
-    value?: string;
-    fee?: string;
-    chain?: string;
-    network?: string;
+    listing?: MarketListing;
+    transactionHash?: string;
     error?: string;
 }
-/**
- * WDK API Client for server-side Tether WDK integration
- */
-declare class WdkApiClient {
-    private config;
-    constructor(config: WdkApiConfig);
-    /**
-     * Generate a new BIP-39 seed phrase using Tether WDK
-     */
-    generateSeed(): Promise<GenerateSeedResponse>;
-    /**
-     * Validate a BIP-39 seed phrase
-     */
-    validateSeed(seed: string): Promise<ValidateSeedResponse>;
-    /**
-     * Derive address for a specific chain using Tether WDK
-     */
-    deriveAddress(seed: string, chain: NetworkType, network?: 'mainnet' | 'testnet'): Promise<DeriveAddressResponse>;
-    /**
-     * Derive addresses for all chains using Tether WDK
-     */
-    deriveAllAddresses(seed: string, network?: 'mainnet' | 'testnet'): Promise<DeriveAllAddressesResponse>;
-    /**
-     * Send a transaction on a specific chain using Tether WDK
-     */
-    sendTransaction(seed: string, chain: NetworkType, to: string, amount: string, network?: 'mainnet' | 'testnet'): Promise<SendTransactionResponse>;
-    /**
-     * Get transaction history for an address on a specific chain
-     * Fetches from blockchain explorers (Etherscan, mempool.space, etc.)
-     */
-    getTransactionHistory(seed: string, chain: NetworkType, network?: 'mainnet' | 'testnet', limit?: number): Promise<TransactionHistoryResponse>;
-    /**
-     * Get transaction status by hash
-     * Fetches from blockchain explorers to check confirmation status
-     */
-    getTransactionStatus(txHash: string, chain: NetworkType, network?: 'mainnet' | 'testnet'): Promise<TransactionStatusResponse>;
+interface BuyItemRequest {
+    listingId: string;
+    buyerAddress: string;
 }
-/**
- * Get or create the WDK API client instance
- */
-declare function getWdkApiClient(baseUrl?: string): WdkApiClient;
-
-/**
- * Browser-Compatible Address Derivation
- *
- * This module provides multi-chain address derivation that works in browser environments.
- * It uses the @scure libraries which are pure JS and don't require Node.js polyfills.
- *
- * Supported chains:
- * - Ethereum: ethers.js (BIP-44)
- * - Bitcoin: @scure/bip32 + @scure/base (BIP-84 native SegWit)
- * - Solana: ed25519-hd-key + tweetnacl (SLIP-0010)
- * - TON: ed25519 derivation with TON address format
- * - TRON: secp256k1 + base58check
- * - Spark: Bitcoin-based with custom derivation
- */
-
-interface ChainAddress$1 {
-    chain: NetworkType;
-    address: string;
-    path: string;
-}
-interface BrowserMultiChainAddresses {
-    ethereum: string | null;
-    bitcoin: string | null;
-    ton: string | null;
-    tron: string | null;
-    solana: string | null;
-    spark: string | null;
+interface BuyItemResponse {
+    success: boolean;
+    transactionHash?: string;
+    tokenId?: string;
+    newOwner?: string;
+    error?: string;
 }
-/**
- * Derive Ethereum address from seed phrase
- */
-declare function deriveEthereumAddress(seed: string): string;
-/**
- * Derive Bitcoin address from seed phrase (BIP-84 native SegWit)
- * Uses @scure libraries for browser compatibility
- */
-declare function deriveBitcoinAddress(seed: string, network?: 'mainnet' | 'testnet'): string;
-/**
- * Derive Solana address from seed phrase using SLIP-0010 (ed25519)
- */
-declare function deriveSolanaAddress(seed: string): Promise<string>;
-/**
- * Derive TON address from seed phrase
- * Uses proper BIP-44 derivation path m/44'/607'/0'/0'/0'
- */
-declare function deriveTonAddress(seed: string): Promise<string>;
-/**
- * Derive TRON address from seed phrase
- * TRON uses secp256k1 like Ethereum but with base58check encoding
- * Uses @scure/base for browser compatibility
- */
-declare function deriveTronAddress(seed: string): string;
-/**
- * Derive Spark address from seed phrase
- * Spark uses its own derivation path and bech32 format
- * Uses @scure libraries for browser compatibility
- */
-declare function deriveSparkAddress(seed: string, network?: 'mainnet' | 'testnet'): string;
-/**
- * Derive addresses for all supported chains
- */
-declare function deriveAllAddresses(seed: string, network?: 'mainnet' | 'testnet'): Promise<BrowserMultiChainAddresses>;
-/**
- * Validate a BIP-39 seed phrase using @scure/bip39
- */
-declare function isValidSeed(seed: string): boolean;
-/**
- * Generate a random BIP-39 seed phrase using @scure/bip39
- */
-declare function generateSeedPhrase(): string;
-
-type BrowserAddressDerivation_BrowserMultiChainAddresses = BrowserMultiChainAddresses;
-declare const BrowserAddressDerivation_deriveAllAddresses: typeof deriveAllAddresses;
-declare const BrowserAddressDerivation_deriveBitcoinAddress: typeof deriveBitcoinAddress;
-declare const BrowserAddressDerivation_deriveEthereumAddress: typeof deriveEthereumAddress;
-declare const BrowserAddressDerivation_deriveSolanaAddress: typeof deriveSolanaAddress;
-declare const BrowserAddressDerivation_deriveSparkAddress: typeof deriveSparkAddress;
-declare const BrowserAddressDerivation_deriveTonAddress: typeof deriveTonAddress;
-declare const BrowserAddressDerivation_deriveTronAddress: typeof deriveTronAddress;
-declare const BrowserAddressDerivation_generateSeedPhrase: typeof generateSeedPhrase;
-declare const BrowserAddressDerivation_isValidSeed: typeof isValidSeed;
-declare namespace BrowserAddressDerivation {
-  export { type BrowserAddressDerivation_BrowserMultiChainAddresses as BrowserMultiChainAddresses, type ChainAddress$1 as ChainAddress, BrowserAddressDerivation_deriveAllAddresses as deriveAllAddresses, BrowserAddressDerivation_deriveBitcoinAddress as deriveBitcoinAddress, BrowserAddressDerivation_deriveEthereumAddress as deriveEthereumAddress, BrowserAddressDerivation_deriveSolanaAddress as deriveSolanaAddress, BrowserAddressDerivation_deriveSparkAddress as deriveSparkAddress, BrowserAddressDerivation_deriveTonAddress as deriveTonAddress, BrowserAddressDerivation_deriveTronAddress as deriveTronAddress, BrowserAddressDerivation_generateSeedPhrase as generateSeedPhrase, BrowserAddressDerivation_isValidSeed as isValidSeed };
+interface CancelListingRequest {
+    listingId: string;
 }
-
-/**
- * Zubari WDK Service - Unified Multi-Chain Wallet Service
- *
- * This service provides a unified interface for multi-chain wallet operations
- * that works in both browser and Node.js environments.
- *
- * Strategy:
- * - Browser: Uses WdkApiClient to call the backend API (which has Tether WDK)
- * - Node.js: Uses WdkService natively (with Tether WDK modules)
- *
- * The Tether WDK (@tetherto/wdk-*) only works in Node.js environments due to
- * native dependencies (Electrum client, gRPC, etc.). For browser environments,
- * we route all operations through the backend API.
- *
- * @see https://docs.wallet.tether.io/
- */
-type SupportedChain = 'ethereum' | 'bitcoin' | 'ton' | 'tron' | 'solana' | 'spark';
-interface ChainAddress {
-    chain: SupportedChain;
-    address: string;
-    path: string;
+interface CancelListingResponse {
+    success: boolean;
+    transactionHash?: string;
+    error?: string;
 }
-interface MultiChainAddresses {
-    ethereum: string | null;
-    bitcoin: string | null;
-    ton: string | null;
-    tron: string | null;
-    solana: string | null;
-    spark: string | null;
+interface UpdatePriceRequest {
+    listingId: string;
+    newPrice: string;
 }
-interface ChainBalance {
-    chain: SupportedChain;
-    address: string;
-    balance: string;
-    symbol: string;
+interface UpdatePriceResponse {
+    success: boolean;
+    listing?: MarketListing;
+    transactionHash?: string;
+    error?: string;
 }
-interface FeeRates {
-    slow: string;
-    normal: string;
-    fast: string;
+interface ListingsResponse {
+    success: boolean;
+    listings?: MarketListing[];
+    pagination?: {
+        page: number;
+        limit: number;
+        total: number;
+        pages: number;
+    };
+    error?: string;
 }
-interface TransactionResult$1 {
+interface MarketStatsResponse {
     success: boolean;
-    txHash?: string;
-    from?: string;
-    to?: string;
-    amount?: string;
-    chain?: string;
-    network?: string;
+    stats?: {
+        totalListings: number;
+        activeListings: number;
+        totalVolume: string;
+        totalSales: number;
+        averagePrice: string;
+        topSellers: Array<{
+            address: string;
+            sales: number;
+            volume: string;
+        }>;
+    };
     error?: string;
 }
-interface ZubariWdkServiceConfig {
-    /** Network to use (mainnet or testnet) */
-    network: 'mainnet' | 'testnet';
-    /** API URL for the Zubari backend (required for browser environments) */
-    apiUrl?: string;
-    /** Force using API even in Node.js (useful for testing) */
-    forceApi?: boolean;
-    /** Request timeout in milliseconds */
-    timeout?: number;
+interface NFTFilters {
+    creatorId?: string;
+    ownerId?: string;
+    isLazyMinted?: boolean;
+    isMinted?: boolean;
+    minPrice?: string;
+    maxPrice?: string;
+    currency?: NFTCurrency;
+    page?: number;
+    limit?: number;
+}
+interface ListingFilters {
+    sellerId?: string;
+    status?: 'ACTIVE' | 'SOLD' | 'CANCELLED' | 'EXPIRED';
+    minPrice?: string;
+    maxPrice?: string;
+    currency?: NFTCurrency;
+    sortBy?: 'price' | 'createdAt' | 'expiresAt';
+    sortOrder?: 'asc' | 'desc';
+    page?: number;
+    limit?: number;
 }
 /**
- * Check if we're running in a browser environment
- */
-declare function isBrowser(): boolean;
-/**
- * ZubariWdkService - Unified wallet service for browser and Node.js
- *
- * This service automatically routes operations to:
- * - API backend (browser) - using WdkApiClient
- * - Native WDK (Node.js) - using WdkService
- * - Browser derivation (fallback) - using BrowserAddressDerivation
+ * Zubari API Client for backend integration
  */
-declare class ZubariWdkService {
+declare class ZubariApiClient {
     private config;
-    private apiClient;
-    private nativeWdkService;
-    private initialized;
-    private useNativeWdk;
-    constructor(config?: Partial<ZubariWdkServiceConfig>);
+    constructor(config: ZubariApiConfig);
     /**
-     * Initialize the service and determine the best strategy
+     * Set the authentication token
      */
-    initialize(): Promise<void>;
+    setAuthToken(token: string): void;
     /**
-     * Get the current execution mode
+     * Clear the authentication token
      */
-    getMode(): 'api' | 'native' | 'browser-fallback';
+    clearAuthToken(): void;
     /**
-     * Check if running in browser
+     * Make an authenticated request to the API
      */
-    isBrowserEnvironment(): boolean;
+    private request;
     /**
-     * Generate a new BIP-39 seed phrase (12 words)
+     * Get all NFTs with optional filters
      */
-    generateSeed(): Promise<string>;
+    getNFTs(filters?: NFTFilters): Promise<NFTListResponse>;
     /**
-     * Validate a BIP-39 seed phrase
+     * Get a single NFT by ID
      */
-    validateSeed(seed: string): Promise<boolean>;
-    /**
-     * Derive address for a specific chain using WDK API
-     *
-     * For Ethereum, falls back to local derivation if API fails.
-     * For other chains, WDK API is required - no placeholder fallback.
-     */
-    deriveAddress(seed: string, chain: SupportedChain): Promise<ChainAddress>;
-    /**
-     * Derive addresses for all supported chains using WDK API
-     *
-     * Uses the backend WDK API for real cryptographically valid addresses.
-     * No placeholder fallback - WDK API is required for multi-chain addresses.
-     */
-    deriveAllAddresses(seed: string): Promise<MultiChainAddresses>;
-    /**
-     * Get balances for all chains
-     */
-    getAllBalances(seed: string): Promise<Record<string, ChainBalance | null>>;
-    /**
-     * Get fee rates for a chain
-     */
-    getFeeRates(seed: string, chain: SupportedChain): Promise<FeeRates>;
-    /**
-     * Estimate transaction fee
-     */
-    estimateFee(seed: string, chain: SupportedChain, to: string, amount: string): Promise<{
-        fee: string;
-        symbol: string;
+    getNFT(nftId: string): Promise<{
+        success: boolean;
+        nft?: NFTResponse;
+        error?: string;
     }>;
     /**
-     * Send a transaction
+     * Create a new NFT (lazy minted)
      */
-    sendTransaction(seed: string, chain: SupportedChain, to: string, amount: string): Promise<TransactionResult$1>;
-    /**
-     * Get the network configuration
-     */
-    getNetwork(): 'mainnet' | 'testnet';
-    /**
-     * Get API URL
-     */
-    getApiUrl(): string;
-    private getDerivationPath;
-    private getChainSymbol;
-    /**
-     * Derive address using browser-compatible libraries
-     */
-    private deriveBrowserAddress;
-    /**
-     * Derive all addresses using browser-compatible libraries
-     */
-    private deriveAllBrowserAddresses;
-}
-/**
- * Get or create the default ZubariWdkService instance
- */
-declare function getZubariWdkService(config?: Partial<ZubariWdkServiceConfig>): ZubariWdkService;
-/**
- * Create a new ZubariWdkService instance
- */
-declare function createZubariWdkService(config?: Partial<ZubariWdkServiceConfig>): ZubariWdkService;
-
-/**
- * Transaction Service for Zubari SDK
- *
- * Provides multi-chain transaction capabilities using Tether WDK.
- * Supports Ethereum, Bitcoin, Solana, TON, TRON, and Spark (Lightning).
- *
- * @see https://docs.wallet.tether.io/
- */
-
-/**
- * Transaction parameters for sending
- */
-interface TransactionParams {
-    /** Recipient address */
-    to: string;
-    /** Amount to send (in human-readable format, e.g., "0.1") */
-    amount: string;
-    /** Token address (optional, for ERC-20/SPL tokens) */
-    token?: string;
-    /** Transaction memo/message (for chains that support it) */
-    memo?: string;
-    /** Fee priority: 'slow' | 'medium' | 'fast' */
-    feePriority?: 'slow' | 'medium' | 'fast';
-    /** Custom gas limit (EVM chains) */
-    gasLimit?: string;
-    /** Custom gas price (EVM chains) */
-    gasPrice?: string;
-}
-/**
- * Transaction result with detailed information
- */
-interface TransactionResult {
-    /** Transaction hash */
-    hash: string;
-    /** Network/chain */
-    network: NetworkType;
-    /** Transaction status */
-    status: 'pending' | 'confirmed' | 'failed';
-    /** Block number (when confirmed) */
-    blockNumber?: number;
-    /** Gas used (EVM chains) */
-    gasUsed?: string;
-    /** Fee paid */
-    fee?: string;
-    /** Explorer URL */
-    explorerUrl?: string;
-    /** Error message if failed */
-    error?: string;
-    /** Timestamp */
-    timestamp: number;
-}
-/**
- * Transaction history item
- */
-interface TransactionHistoryItem {
-    hash: string;
-    network: NetworkType;
-    type: 'send' | 'receive' | 'swap' | 'contract';
-    from: string;
-    to: string;
-    amount: string;
-    token?: string;
-    fee?: string;
-    status: 'pending' | 'confirmed' | 'failed';
-    timestamp: number;
-    blockNumber?: number;
-}
-/**
- * Fee estimate for a transaction
- */
-interface FeeEstimate {
-    slow: {
-        fee: string;
-        estimatedTime: string;
-    };
-    medium: {
-        fee: string;
-        estimatedTime: string;
-    };
-    fast: {
-        fee: string;
-        estimatedTime: string;
-    };
-}
-/**
- * Transaction Service configuration
- */
-interface TransactionServiceConfig {
-    network: 'mainnet' | 'testnet';
-    rpcUrls?: Partial<Record<NetworkType, string>>;
-}
-/**
- * Transaction Service
- *
- * Provides multi-chain transaction capabilities:
- * - Send native tokens (ETH, BTC, SOL, TON, TRX)
- * - Send ERC-20/SPL tokens
- * - Fee estimation
- * - Transaction history
- */
-declare class TransactionService {
-    private seed;
-    private config;
-    private wallets;
-    constructor(config?: Partial<TransactionServiceConfig>);
-    /**
-     * Ensure WDK modules are loaded
-     */
-    private ensureLoaded;
-    /**
-     * Get RPC URL for a chain
-     */
-    private getRpcUrl;
-    /**
-     * Get explorer URL for a transaction
-     */
-    getExplorerUrl(chain: NetworkType, txHash: string): string;
+    createNFT(data: CreateNFTRequest, image: File | Blob): Promise<{
+        success: boolean;
+        nft?: NFTResponse;
+        error?: string;
+    }>;
     /**
-     * Initialize the service with a seed phrase
+     * Create a voucher for an NFT (EIP-712 signed)
      */
-    initialize(seed: string): Promise<void>;
+    createVoucher(nftId: string, params: CreateVoucherRequest): Promise<CreateVoucherResponse>;
     /**
-     * Check if service is initialized
+     * Redeem an NFT voucher (buy/mint)
      */
-    isInitialized(): boolean;
+    redeemVoucher(nftId: string, params: RedeemVoucherRequest): Promise<RedeemVoucherResponse>;
     /**
-     * Get or create wallet instance for a specific chain
+     * Get voucher status for an NFT
      */
-    private getWallet;
+    getVoucherStatus(nftId: string): Promise<VoucherStatusResponse>;
     /**
-     * Estimate transaction fee
+     * Get all active listings
      */
-    estimateFee(chain: NetworkType, params: TransactionParams): Promise<FeeEstimate>;
+    getListings(filters?: ListingFilters): Promise<ListingsResponse>;
     /**
-     * Send a transaction
+     * List an NFT for sale
      */
-    send(chain: NetworkType, params: TransactionParams): Promise<TransactionResult>;
+    listItem(params: ListItemRequest): Promise<ListItemResponse>;
     /**
-     * Get transaction status
+     * Buy a listed NFT
      */
-    getTransactionStatus(chain: NetworkType, txHash: string): Promise<TransactionResult>;
+    buyItem(params: BuyItemRequest): Promise<BuyItemResponse>;
     /**
-     * Get transaction history for an address
+     * Cancel a listing
      */
-    getTransactionHistory(chain: NetworkType, limit?: number): Promise<TransactionHistoryItem[]>;
+    cancelListing(params: CancelListingRequest): Promise<CancelListingResponse>;
     /**
-     * Get balance for a specific chain
+     * Update listing price
      */
-    getBalance(chain: NetworkType): Promise<{
-        balance: string;
-        balanceUsd: number;
-    }>;
+    updateListingPrice(params: UpdatePriceRequest): Promise<UpdatePriceResponse>;
     /**
-     * Get the current network configuration
+     * Get current user's listings
      */
-    getNetwork(): 'mainnet' | 'testnet';
+    getMyListings(filters?: Omit<ListingFilters, 'sellerId'>): Promise<ListingsResponse>;
     /**
-     * Clean up and dispose of wallet instances
+     * Get marketplace statistics
      */
-    dispose(): void;
+    getMarketStats(): Promise<MarketStatsResponse>;
 }
 /**
- * Get or create the Transaction service singleton
+ * Get or create the Zubari API client instance
  */
-declare function getTransactionService(config?: Partial<TransactionServiceConfig>): TransactionService;
+declare function getZubariApiClient(config?: Partial<ZubariApiConfig>): ZubariApiClient;
 /**
- * Create a new Transaction service instance (non-singleton)
+ * Create a new Zubari API client instance
  */
-declare function createTransactionService(config?: Partial<TransactionServiceConfig>): TransactionService;
+declare function createZubariApiClient(config: ZubariApiConfig): ZubariApiClient;
 
-export { BrowserAddressDerivation, type ChainAddress$1 as BrowserChainAddress, type BrowserMultiChainAddresses, type ChainAddress, type ChainBalance, type DeriveAddressResponse, type DeriveAllAddressesResponse, type FeeEstimate, type FeeRates, type GenerateSeedResponse, type MultiChainAddresses, type SendTransactionResponse, type SupportedChain, SwapService, type TransactionHistoryItem, type TransactionHistoryResponse, type TransactionParams, type TransactionResult, TransactionService, type TransactionServiceConfig, type TransactionStatusResponse, type ValidateSeedResponse, WdkApiClient, type WdkApiConfig, type TransactionHistoryItem$1 as WdkTransactionHistoryItem, type TransactionResult$1 as WdkTransactionResult, ZubariWdkService, type ZubariWdkServiceConfig, createTransactionService, createZubariWdkService, getTransactionService, getWdkApiClient, getZubariWdkService, isBrowser };
+export { type BuyItemRequest, type BuyItemResponse, type CancelListingRequest, type CancelListingResponse, type CreateNFTRequest, type CreateVoucherRequest, type CreateVoucherResponse, type ListItemRequest, type ListItemResponse, type ListingFilters, type ListingsResponse, type MarketListing, type MarketStatsResponse, type NFTFilters, type NFTListResponse, type NFTResponse, type NFTVoucher, type RedeemVoucherRequest, type RedeemVoucherResponse, type UpdatePriceRequest, type UpdatePriceResponse, type VoucherStatusResponse, ZubariApiClient, type ZubariApiConfig, createZubariApiClient, getZubariApiClient };