@zubari/sdk 0.2.4 → 0.2.6

package/dist/services/index.d.mts

@@ -1,579 +1,705 @@
-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 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 DeriveAddressResponse {
+interface CreateVoucherRequest {
+    creatorAddress: string;
+    price: string;
+    currency: NFTCurrency;
+}
+interface CreateVoucherResponse {
     success: boolean;
-    address?: string;
-    chain?: string;
-    path?: string;
-    network?: string;
+    voucher?: NFTVoucher;
+    signature?: string;
+    nftId?: string;
+    error?: string;
+}
+interface RedeemVoucherRequest {
+    buyerAddress: string;
+    paymentTxHash?: string;
+}
+interface RedeemVoucherResponse {
+    success: boolean;
+    transactionHash?: string;
+    tokenId?: string;
+    owner?: string;
+    nftId?: string;
+    error?: string;
+}
+interface VoucherStatusResponse {
+    success: boolean;
+    nftId?: string;
+    hasVoucher?: boolean;
+    isRedeemed?: boolean;
+    voucher?: NFTVoucher;
+    error?: string;
+}
+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 CreateNFTRequest {
+    name: string;
+    description?: string;
+    price: string;
+    currency: NFTCurrency;
+    royaltyBps?: number;
+    attributes?: Array<{
+        trait_type: string;
+        value: string | number;
+    }>;
+    externalUrl?: string;
+}
+interface NFTListResponse {
+    success: boolean;
+    nfts?: NFTResponse[];
+    pagination?: {
+        page: number;
+        limit: number;
+        total: number;
+        pages: number;
+    };
+    error?: string;
+}
+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;
+    listing?: MarketListing;
+    transactionHash?: string;
+    error?: string;
+}
+interface BuyItemRequest {
+    listingId: string;
+    buyerAddress: string;
+}
+interface BuyItemResponse {
+    success: boolean;
+    transactionHash?: string;
+    tokenId?: string;
+    newOwner?: string;
+    error?: string;
+}
+interface CancelListingRequest {
+    listingId: string;
+}
+interface CancelListingResponse {
+    success: boolean;
+    transactionHash?: string;
+    error?: string;
+}
+interface UpdatePriceRequest {
+    listingId: string;
+    newPrice: string;
+}
+interface UpdatePriceResponse {
+    success: boolean;
+    listing?: MarketListing;
+    transactionHash?: string;
+    error?: string;
+}
+interface ListingsResponse {
+    success: boolean;
+    listings?: MarketListing[];
+    pagination?: {
+        page: number;
+        limit: number;
+        total: number;
+        pages: number;
+    };
     error?: string;
 }
-interface DeriveAllAddressesResponse {
+interface MarketStatsResponse {
     success: boolean;
-    addresses?: {
-        ethereum: string | null;
-        bitcoin: string | null;
-        ton: string | null;
-        tron: string | null;
-        solana: string | null;
-        spark: string | null;
+    stats?: {
+        totalListings: number;
+        activeListings: number;
+        totalVolume: string;
+        totalSales: number;
+        averagePrice: string;
+        topSellers: Array<{
+            address: string;
+            sales: number;
+            volume: string;
+        }>;
     };
+    error?: string;
+}
+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;
+}
+interface TipUser {
+    id: string;
+    username?: string;
+    displayName?: string;
+    avatarUrl?: string;
+}
+interface Tip {
+    id: string;
+    senderId: string;
+    recipientId?: string;
+    senderAddress: string;
+    recipientAddress: string;
+    tokenAddress?: string;
+    amount: string;
+    amountUsd?: string;
+    platformFee: string;
+    message?: string;
+    network: string;
+    transactionHash?: string;
+    status: 'PENDING' | 'CONFIRMED' | 'FAILED';
+    createdAt: string;
+    sender?: TipUser;
+    recipient?: TipUser;
+}
+interface SendTipRequest {
+    recipientAddress: string;
+    recipientUsername?: string;
+    amount: string;
+    tokenAddress?: string;
     network?: string;
+    message?: string;
+    transactionHash?: string;
+}
+interface SendTipResponse {
+    success: boolean;
+    message?: string;
+    tip?: Tip;
+    platformFee?: string;
+    platformFeeBps?: number;
+    error?: string;
+}
+interface TipStatsResponse {
+    success: boolean;
+    sent?: {
+        count: number;
+        totalAmount: string;
+        totalAmountUsd: string;
+    };
+    received?: {
+        count: number;
+        totalAmount: string;
+        totalAmountUsd: string;
+        platformFees: string;
+    };
+    error?: string;
+}
+interface TipsListResponse {
+    success: boolean;
+    tips?: Tip[];
+    pagination?: {
+        page: number;
+        limit: number;
+        total: number;
+        totalPages: number;
+    };
+    totals?: {
+        count: number;
+        amount: string;
+        amountUsd: string;
+    };
+    error?: string;
+}
+interface TipFilters {
+    page?: number;
+    limit?: number;
+    status?: 'PENDING' | 'CONFIRMED' | 'FAILED';
+}
+interface UpdateTipStatusRequest {
+    status: 'PENDING' | 'CONFIRMED' | 'FAILED';
+    transactionHash?: string;
+}
+interface SubscriptionPlan {
+    id: string;
+    creatorId: string;
+    name: string;
+    description?: string;
+    price: string;
+    priceUsd?: string;
+    paymentToken?: string;
+    durationDays: number;
+    perks: string[];
+    nftBadge: boolean;
+    maxSubscribers?: number;
+    isActive: boolean;
+    activeSubscribers?: number;
+    createdAt: string;
+    updatedAt: string;
+    creator?: TipUser & {
+        isVerified?: boolean;
+    };
+}
+interface Subscription {
+    id: string;
+    planId: string;
+    subscriberId: string;
+    creatorId: string;
+    subscriberAddress?: string;
+    creatorAddress?: string;
+    transactionHash?: string;
+    amount?: string;
+    startDate: string;
+    endDate: string;
+    expiresAt: string;
+    autoRenew: boolean;
+    status: 'ACTIVE' | 'EXPIRED' | 'CANCELLED';
+    createdAt: string;
+    plan?: Partial<SubscriptionPlan>;
+    creator?: TipUser & {
+        isVerified?: boolean;
+    };
+    subscriber?: TipUser;
+}
+interface CreatePlanRequest {
+    name: string;
+    description?: string;
+    price: string;
+    priceUsd?: number;
+    paymentToken?: string;
+    durationDays?: number;
+    perks?: string[];
+    nftBadge?: boolean;
+    maxSubscribers?: number;
+}
+interface CreatePlanResponse {
+    success: boolean;
+    message?: string;
+    plan?: SubscriptionPlan;
+    error?: string;
+}
+interface SubscribeRequest {
+    planId: string;
+    transactionHash?: string;
+    autoRenew?: boolean;
+}
+interface SubscribeResponse {
+    success: boolean;
+    message?: string;
+    subscription?: Subscription;
     error?: string;
 }
-interface ValidateSeedResponse {
+interface SubscriptionListResponse {
     success: boolean;
-    isValid?: boolean;
-    wordCount?: number;
+    subscriptions?: Subscription[];
+    pagination?: {
+        page: number;
+        limit: number;
+        total: number;
+        totalPages: number;
+    };
+    stats?: {
+        totalSubscribers: number;
+    };
     error?: string;
 }
-interface GenerateSeedResponse {
+interface SubscriptionFilters {
+    page?: number;
+    limit?: number;
+    status?: 'ACTIVE' | 'EXPIRED' | 'CANCELLED';
+}
+interface ContractSubscribeRequest {
+    planId: string;
+    months?: number;
+    seed: string;
+}
+interface ContractSubscribeResponse {
     success: boolean;
-    seed?: string;
-    wordCount?: number;
+    transactionHash?: string;
+    subscription?: Subscription;
+    message?: string;
     error?: string;
 }
-interface TransactionHistoryItem$1 {
-    hash: string;
-    from: string;
-    to: string;
-    value: string;
-    timestamp: number;
-    status: 'confirmed' | 'pending' | 'failed';
-    blockNumber?: number;
+interface ContractCreatePlanRequest {
+    name: string;
+    description?: string;
+    price: string;
+    paymentToken?: string;
+    durationDays?: number;
+    maxSubscribers?: number;
+    seed: string;
 }
-interface TransactionHistoryResponse {
+interface ContractCreatePlanResponse {
+    success: boolean;
+    transactionHash?: string;
+    plan?: SubscriptionPlan;
+    message?: string;
+    error?: string;
+}
+interface IsSubscribedResponse {
+    subscriber: string;
+    creator: string;
+    isSubscribed: boolean;
+}
+interface PlatformFeeResponse {
+    feeBps: number;
+    feePercent: string;
+}
+interface EarningsResponse {
     success: boolean;
     address?: string;
-    transactions?: TransactionHistoryItem$1[];
-    chain?: string;
-    network?: string;
+    pendingEarnings?: string;
+    totalEarnings?: string;
+    earningsBreakdown?: {
+        tips: string;
+        subscriptions: string;
+        nftSales: string;
+        royalties: string;
+    };
+    recentPayouts?: Array<{
+        id: string;
+        amount: string;
+        txHash: string;
+        createdAt: string;
+    }>;
     error?: string;
 }
-interface SendTransactionResponse {
+interface ClaimEarningsRequest {
+    seed: string;
+}
+interface ClaimEarningsResponse {
     success: boolean;
-    txHash?: string;
-    from?: string;
-    to?: string;
+    transactionHash?: string;
     amount?: string;
-    chain?: string;
-    network?: string;
+    message?: string;
     error?: string;
 }
-interface TransactionStatusResponse {
+interface PayoutHistoryResponse {
     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;
+    payouts?: Array<{
+        id: string;
+        amount: string;
+        status: string;
+        txHash: string;
+        createdAt: string;
+        confirmedAt?: string;
+    }>;
+    pagination?: {
+        page: number;
+        limit: number;
+        total: number;
+        pages: number;
+    };
+    error?: string;
+}
+interface EarningsBreakdownResponse {
+    success: boolean;
+    breakdown?: {
+        tips: string;
+        subscriptions: string;
+        nftSales: string;
+        royalties: string;
+        total: string;
+    };
+    percentages?: {
+        tips: string;
+        subscriptions: string;
+        nftSales: string;
+        royalties: string;
+    };
     error?: string;
 }
 /**
- * WDK API Client for server-side Tether WDK integration
+ * Zubari API Client for backend integration
  */
-declare class WdkApiClient {
+declare class ZubariApiClient {
     private config;
-    constructor(config: WdkApiConfig);
+    constructor(config: ZubariApiConfig);
     /**
-     * Generate a new BIP-39 seed phrase using Tether WDK
+     * Set the authentication token
      */
-    generateSeed(): Promise<GenerateSeedResponse>;
+    setAuthToken(token: string): void;
     /**
-     * Validate a BIP-39 seed phrase
+     * Clear the authentication token
      */
-    validateSeed(seed: string): Promise<ValidateSeedResponse>;
+    clearAuthToken(): void;
     /**
-     * Derive address for a specific chain using Tether WDK
+     * Make an authenticated request to the API
      */
-    deriveAddress(seed: string, chain: NetworkType, network?: 'mainnet' | 'testnet'): Promise<DeriveAddressResponse>;
+    private request;
     /**
-     * Derive addresses for all chains using Tether WDK
+     * Get all NFTs with optional filters
      */
-    deriveAllAddresses(seed: string, network?: 'mainnet' | 'testnet'): Promise<DeriveAllAddressesResponse>;
+    getNFTs(filters?: NFTFilters): Promise<NFTListResponse>;
     /**
-     * Send a transaction on a specific chain using Tether WDK
+     * Get a single NFT by ID
      */
-    sendTransaction(seed: string, chain: NetworkType, to: string, amount: string, network?: 'mainnet' | 'testnet'): Promise<SendTransactionResponse>;
+    getNFT(nftId: string): Promise<{
+        success: boolean;
+        nft?: NFTResponse;
+        error?: string;
+    }>;
     /**
-     * Get transaction history for an address on a specific chain
-     * Fetches from blockchain explorers (Etherscan, mempool.space, etc.)
+     * Create a new NFT (lazy minted)
      */
-    getTransactionHistory(seed: string, chain: NetworkType, network?: 'mainnet' | 'testnet', limit?: number): Promise<TransactionHistoryResponse>;
+    createNFT(data: CreateNFTRequest, image: File | Blob): Promise<{
+        success: boolean;
+        nft?: NFTResponse;
+        error?: string;
+    }>;
     /**
-     * Get transaction status by hash
-     * Fetches from blockchain explorers to check confirmation status
+     * Create a voucher for an NFT (EIP-712 signed)
      */
-    getTransactionStatus(txHash: string, chain: NetworkType, network?: 'mainnet' | 'testnet'): Promise<TransactionStatusResponse>;
-}
-/**
- * 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;
-}
-/**
- * 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 };
-}
-
-/**
- * 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 MultiChainAddresses {
-    ethereum: string | null;
-    bitcoin: string | null;
-    ton: string | null;
-    tron: string | null;
-    solana: string | null;
-    spark: string | null;
-}
-interface ChainBalance {
-    chain: SupportedChain;
-    address: string;
-    balance: string;
-    symbol: string;
-}
-interface FeeRates {
-    slow: string;
-    normal: string;
-    fast: string;
-}
-interface TransactionResult$1 {
-    success: boolean;
-    txHash?: string;
-    from?: string;
-    to?: string;
-    amount?: string;
-    chain?: string;
-    network?: 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;
-}
-/**
- * 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
- */
-declare class ZubariWdkService {
-    private config;
-    private apiClient;
-    private nativeWdkService;
-    private initialized;
-    private useNativeWdk;
-    constructor(config?: Partial<ZubariWdkServiceConfig>);
+    createVoucher(nftId: string, params: CreateVoucherRequest): Promise<CreateVoucherResponse>;
     /**
-     * Initialize the service and determine the best strategy
+     * Redeem an NFT voucher (buy/mint)
      */
-    initialize(): Promise<void>;
+    redeemVoucher(nftId: string, params: RedeemVoucherRequest): Promise<RedeemVoucherResponse>;
     /**
-     * Get the current execution mode
+     * Get voucher status for an NFT
      */
-    getMode(): 'api' | 'native' | 'browser-fallback';
+    getVoucherStatus(nftId: string): Promise<VoucherStatusResponse>;
     /**
-     * Check if running in browser
+     * Get all active listings
      */
-    isBrowserEnvironment(): boolean;
+    getListings(filters?: ListingFilters): Promise<ListingsResponse>;
     /**
-     * Generate a new BIP-39 seed phrase (12 words)
+     * List an NFT for sale
      */
-    generateSeed(): Promise<string>;
+    listItem(params: ListItemRequest): Promise<ListItemResponse>;
     /**
-     * Validate a BIP-39 seed phrase
+     * Buy a listed NFT
      */
-    validateSeed(seed: string): Promise<boolean>;
+    buyItem(params: BuyItemRequest): Promise<BuyItemResponse>;
     /**
-     * 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.
+     * Cancel a listing
      */
-    deriveAddress(seed: string, chain: SupportedChain): Promise<ChainAddress>;
+    cancelListing(params: CancelListingRequest): Promise<CancelListingResponse>;
     /**
-     * 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.
+     * Update listing price
      */
-    deriveAllAddresses(seed: string): Promise<MultiChainAddresses>;
+    updateListingPrice(params: UpdatePriceRequest): Promise<UpdatePriceResponse>;
     /**
-     * Get balances for all chains
+     * Get current user's listings
      */
-    getAllBalances(seed: string): Promise<Record<string, ChainBalance | null>>;
+    getMyListings(filters?: Omit<ListingFilters, 'sellerId'>): Promise<ListingsResponse>;
     /**
-     * Get fee rates for a chain
+     * Get marketplace statistics
      */
-    getFeeRates(seed: string, chain: SupportedChain): Promise<FeeRates>;
+    getMarketStats(): Promise<MarketStatsResponse>;
     /**
-     * Estimate transaction fee
+     * Send a tip to a creator
      */
-    estimateFee(seed: string, chain: SupportedChain, to: string, amount: string): Promise<{
-        fee: string;
-        symbol: string;
-    }>;
+    sendTip(params: SendTipRequest): Promise<SendTipResponse>;
     /**
-     * Send a transaction
+     * Get tip statistics for current user
      */
-    sendTransaction(seed: string, chain: SupportedChain, to: string, amount: string): Promise<TransactionResult$1>;
+    getTipStats(): Promise<TipStatsResponse>;
     /**
-     * Get the network configuration
+     * Get tips sent by current user
      */
-    getNetwork(): 'mainnet' | 'testnet';
+    getSentTips(filters?: TipFilters): Promise<TipsListResponse>;
     /**
-     * Get API URL
+     * Get tips received by current user
      */
-    getApiUrl(): string;
-    private getDerivationPath;
-    private getChainSymbol;
+    getReceivedTips(filters?: TipFilters): Promise<TipsListResponse>;
     /**
-     * Derive address using browser-compatible libraries
+     * Get a single tip by ID
      */
-    private deriveBrowserAddress;
+    getTip(tipId: string): Promise<{
+        success: boolean;
+        tip?: Tip;
+        error?: string;
+    }>;
     /**
-     * Derive all addresses using browser-compatible libraries
+     * Update tip status (for transaction confirmation)
      */
-    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>);
+    updateTipStatus(tipId: string, params: UpdateTipStatusRequest): Promise<{
+        success: boolean;
+        tip?: Tip;
+        message?: string;
+        error?: string;
+    }>;
     /**
-     * Ensure WDK modules are loaded
+     * Create a new subscription plan (creator only)
      */
-    private ensureLoaded;
+    createSubscriptionPlan(params: CreatePlanRequest): Promise<CreatePlanResponse>;
     /**
-     * Get RPC URL for a chain
+     * Get current user's subscription plans
      */
-    private getRpcUrl;
+    getMySubscriptionPlans(): Promise<{
+        success: boolean;
+        plans?: SubscriptionPlan[];
+        error?: string;
+    }>;
     /**
-     * Get explorer URL for a transaction
+     * Get subscription plan by ID
      */
-    getExplorerUrl(chain: NetworkType, txHash: string): string;
+    getSubscriptionPlan(planId: string): Promise<{
+        success: boolean;
+        plan?: SubscriptionPlan & {
+            isSubscribed?: boolean;
+        };
+        error?: string;
+    }>;
     /**
-     * Initialize the service with a seed phrase
+     * Delete/deactivate subscription plan
      */
-    initialize(seed: string): Promise<void>;
+    deleteSubscriptionPlan(planId: string): Promise<{
+        success: boolean;
+        message?: string;
+        deactivated?: boolean;
+        error?: string;
+    }>;
     /**
-     * Check if service is initialized
+     * Subscribe to a plan
      */
-    isInitialized(): boolean;
+    subscribe(params: SubscribeRequest): Promise<SubscribeResponse>;
     /**
-     * Get or create wallet instance for a specific chain
+     * Get current user's subscriptions (as subscriber)
      */
-    private getWallet;
+    getMySubscriptions(filters?: SubscriptionFilters): Promise<SubscriptionListResponse>;
     /**
-     * Estimate transaction fee
+     * Get subscribers to current user's plans (as creator)
      */
-    estimateFee(chain: NetworkType, params: TransactionParams): Promise<FeeEstimate>;
+    getMySubscribers(filters?: SubscriptionFilters): Promise<SubscriptionListResponse>;
     /**
-     * Send a transaction
+     * Cancel subscription
      */
-    send(chain: NetworkType, params: TransactionParams): Promise<TransactionResult>;
+    cancelSubscription(subscriptionId: string): Promise<{
+        success: boolean;
+        message?: string;
+        error?: string;
+    }>;
     /**
-     * Get transaction status
+     * Create a subscription plan on-chain
      */
-    getTransactionStatus(chain: NetworkType, txHash: string): Promise<TransactionResult>;
+    createSubscriptionPlanOnChain(params: ContractCreatePlanRequest): Promise<ContractCreatePlanResponse>;
     /**
-     * Get transaction history for an address
+     * Subscribe to a plan on-chain
      */
-    getTransactionHistory(chain: NetworkType, limit?: number): Promise<TransactionHistoryItem[]>;
+    subscribeOnChain(params: ContractSubscribeRequest): Promise<ContractSubscribeResponse>;
     /**
-     * Get balance for a specific chain
+     * Cancel subscription on-chain
      */
-    getBalance(chain: NetworkType): Promise<{
-        balance: string;
-        balanceUsd: number;
+    cancelSubscriptionOnChain(subscriptionId: string, seed: string): Promise<{
+        success: boolean;
+        transactionHash?: string;
+        message?: string;
+        error?: string;
     }>;
     /**
-     * Get the current network configuration
+     * Check if user is subscribed to a creator on-chain
+     */
+    isSubscribed(subscriber: string, creator: string): Promise<IsSubscribedResponse>;
+    /**
+     * Get subscription platform fee
+     */
+    getSubscriptionPlatformFee(): Promise<PlatformFeeResponse>;
+    /**
+     * Get pending and claimed earnings for the authenticated user
+     */
+    getEarnings(): Promise<EarningsResponse>;
+    /**
+     * Claim pending earnings
+     */
+    claimEarnings(params: ClaimEarningsRequest): Promise<ClaimEarningsResponse>;
+    /**
+     * Get payout history for the authenticated user
+     */
+    getPayoutHistory(filters?: {
+        page?: number;
+        limit?: number;
+    }): Promise<PayoutHistoryResponse>;
+    /**
+     * Get earnings breakdown by source
      */
-    getNetwork(): 'mainnet' | 'testnet';
+    getEarningsBreakdown(): Promise<EarningsBreakdownResponse>;
     /**
-     * Clean up and dispose of wallet instances
+     * Get current platform fee for payouts
      */
-    dispose(): void;
+    getPayoutsPlatformFee(): Promise<PlatformFeeResponse>;
 }
 /**
- * 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 ClaimEarningsRequest, type ClaimEarningsResponse, type ContractCreatePlanRequest, type ContractCreatePlanResponse, type ContractSubscribeRequest, type ContractSubscribeResponse, type CreateNFTRequest, type CreatePlanRequest, type CreatePlanResponse, type CreateVoucherRequest, type CreateVoucherResponse, type EarningsBreakdownResponse, type EarningsResponse, type IsSubscribedResponse, type ListItemRequest, type ListItemResponse, type ListingFilters, type ListingsResponse, type MarketListing, type MarketStatsResponse, type NFTFilters, type NFTListResponse, type NFTResponse, type NFTVoucher, type PayoutHistoryResponse, type PlatformFeeResponse, type RedeemVoucherRequest, type RedeemVoucherResponse, type SendTipRequest, type SendTipResponse, type SubscribeRequest, type SubscribeResponse, type Subscription, type SubscriptionFilters, type SubscriptionListResponse, type SubscriptionPlan, type Tip, type TipFilters, type TipStatsResponse, type TipUser, type TipsListResponse, type UpdatePriceRequest, type UpdatePriceResponse, type UpdateTipStatusRequest, type VoucherStatusResponse, ZubariApiClient, type ZubariApiConfig, createZubariApiClient, getZubariApiClient };