@zubari/sdk 0.3.7 → 0.4.0

package/dist/protocols/index.d.mts

@@ -1,93 +1,19 @@
-import { C as CreateVoucherParams, L as LazyMintVoucher, e as NFTMetadata, c as TxResult, g as ListingParams, f as NFT, B as BuyParams, h as Listing, l as Tip, m as SubscriptionPlan, n as Subscription, E as EarningsBreakdown, t as EarningsResponse, P as PayoutHistoryResponse, u as BreakdownResponse, v as PlatformFeeResponse, w as ClaimResult, R as RevenueSplit } from '../index-DF0Gf8NK.mjs';
+export { a as ZubariMarketProtocol, Z as ZubariNFTProtocol, d as ZubariPayoutsProtocol, c as ZubariSubscriptionProtocol, b as ZubariTipsProtocol } from '../PayoutsProtocol-CLiMFe54.mjs';
+import { T as TxResult, C as Creator, S as SubscriptionPlan, a as Subscription } from '../index-CTyZlHKg.mjs';
 
 /**
- * ZubariNFTProtocol - NFT creation and marketplace operations
+ * ZubariSubscriptionV2Protocol - Subscription payments with integrated payouts
  *
- * Handles lazy minting via EIP-712 signatures, NFT listing,
- * and marketplace operations on Ethereum network.
- */
-declare class ZubariNFTProtocol {
-    private readonly contractAddress;
-    private readonly _marketplaceAddress;
-    private readonly chainId;
-    private readonly network;
-    private readonly apiClient;
-    private nonceCounter;
-    constructor(contractAddress: string, marketplaceAddress: string, chainId: number, network?: 'testnet' | 'mainnet', apiUrl?: string);
-    /**
-     * Convert human-readable price to wei
-     * @param price - Price in human-readable format (e.g., "1.5")
-     * @param currency - ETH (18 decimals) or USDT (6 decimals)
-     */
-    private priceToWei;
-    /**
-     * Get currency address for the configured network
-     */
-    private getCurrencyAddress;
-    /**
-     * Generate a unique nonce
-     */
-    private generateNonce;
-    /**
-     * Pad string to bytes32 format
-     */
-    private toBytes32;
-    /**
-     * Create a lazy mint voucher for off-chain NFT creation
-     * The voucher can be redeemed on-chain when purchased
-     *
-     * @param params - Voucher creation parameters
-     * @param signer - Object with signTypedData method (ethers.js wallet or viem client)
-     */
-    createLazyMintVoucher(params: CreateVoucherParams, signer: {
-        signTypedData: (domain: object, types: object, value: object) => Promise<string>;
-    }): Promise<LazyMintVoucher>;
-    /**
-     * @deprecated Use createLazyMintVoucher(params, signer) instead
-     * Legacy method for backward compatibility
-     */
-    createLazyMintVoucherLegacy(metadata: NFTMetadata, creatorAddress: string, signer: {
-        signTypedData: (domain: object, types: object, value: object) => Promise<string>;
-    }): Promise<LazyMintVoucher>;
-    /**
-     * Redeem a lazy mint voucher to mint the NFT on-chain
-     * Uses the backend API which handles the on-chain transaction
-     */
-    redeemVoucher(voucher: LazyMintVoucher, buyerAddress: string, nftId: string, authToken: string): Promise<TxResult>;
-    /**
-     * List an NFT for sale on the marketplace via backend API
-     */
-    listForSale(params: ListingParams, authToken: string): Promise<TxResult>;
-    /**
-     * Buy an NFT from the marketplace via backend API
-     */
-    buyNFT(listingId: string, price: bigint, buyerAddress: string): Promise<TxResult>;
-    /**
-     * Transfer an NFT to another address
-     * Note: This requires direct contract interaction via wallet
-     */
-    transfer(tokenId: string, to: string, from: string, signer: {
-        sendTransaction: (tx: object) => Promise<{
-            hash: string;
-        }>;
-    }): Promise<TxResult>;
-    /**
-     * Get NFTs owned by an address via backend API
-     */
-    getOwnedNFTs(address: string): Promise<NFT[]>;
-    /**
-     * Generate a random tokenId (32 bytes hex)
-     */
-    private generateTokenId;
-}
-
-/**
- * ZubariMarketProtocol - NFT Marketplace operations
+ * Handles creator registration, subscription plan creation, subscription management,
+ * and automatic earnings distribution to ZubariPayouts contract.
  *
- * Handles NFT listings, purchases, and marketplace management
- * with support for ETH and ERC-20 payment tokens.
+ * Key features:
+ * - Creator registration with configurable payout wallet (WDK or MetaMask)
+ * - Multiple subscription plans per creator
+ * - Automatic fee split: 10% to treasury, 90% to Payouts contract
+ * - Support for ETH and ERC-20 payments
  */
-declare class ZubariMarketProtocol {
+declare class ZubariSubscriptionV2Protocol {
     private readonly contractAddress;
     private readonly chainId;
     private readonly abi;
@@ -137,11 +63,6 @@ declare class ZubariMarketProtocol {
         }[];
         name: string;
         outputs: {
-            components: {
-                internalType: string;
-                name: string;
-                type: string;
-            }[];
             internalType: string;
             name: string;
             type: string;
@@ -157,6 +78,11 @@ declare class ZubariMarketProtocol {
         }[];
         name: string;
         outputs: {
+            components: {
+                internalType: string;
+                name: string;
+                type: string;
+            }[];
             internalType: string;
             name: string;
             type: string;
@@ -164,362 +90,119 @@ declare class ZubariMarketProtocol {
         stateMutability: string;
         type: string;
         anonymous?: undefined;
+    } | {
+        stateMutability: string;
+        type: string;
+        inputs?: undefined;
+        name?: undefined;
+        anonymous?: undefined;
+        outputs?: undefined;
     })[];
     /**
      * Get the contract address
      */
     getAddress(): string;
     /**
-     * List an NFT for sale
-     * @param params Listing parameters
+     * Register as a creator with a payout wallet
+     * @param payoutWallet The wallet that will receive payments (WDK wallet by default)
      * @param signer Wallet signer with sendTransaction method
      */
-    listItem(params: ListingParams, signer: {
-        sendTransaction: (tx: object) => Promise<{
-            hash: string;
-        }>;
-    }): Promise<TxResult>;
-    /**
-     * Buy an NFT from a listing
-     * @param params Buy parameters
-     * @param signer Wallet signer
-     */
-    buyItem(params: BuyParams, signer: {
+    registerCreator(payoutWallet: string, signer: {
         sendTransaction: (tx: object) => Promise<{
             hash: string;
         }>;
     }): Promise<TxResult>;
     /**
-     * Cancel a listing
-     * @param listingId The listing ID to cancel
-     * @param signer Wallet signer
+     * Prepare transaction data for creator registration (for frontend signing)
+     * @param payoutWallet The wallet that will receive payments
      */
-    cancelListing(listingId: string, signer: {
-        sendTransaction: (tx: object) => Promise<{
-            hash: string;
-        }>;
-    }): Promise<TxResult>;
+    prepareRegisterCreator(payoutWallet: string): Promise<{
+        to: string;
+        data: string;
+        value: string;
+    }>;
     /**
-     * Update listing price
-     * @param listingId The listing ID
-     * @param newPrice New price
+     * Update the payout wallet address
+     * @param newWallet New wallet address (can be WDK or MetaMask)
      * @param signer Wallet signer
      */
-    updatePrice(listingId: string, newPrice: bigint, signer: {
+    updatePayoutWallet(newWallet: string, signer: {
         sendTransaction: (tx: object) => Promise<{
             hash: string;
         }>;
     }): Promise<TxResult>;
     /**
-     * Get listing details
-     * @param listingId The listing ID
+     * Get creator information
+     * @param creatorAddress The creator's address
      * @param provider JSON-RPC provider
      */
-    getListing(listingId: string, provider: {
+    getCreator(creatorAddress: string, provider: {
         call: (tx: object) => Promise<string>;
-    }): Promise<Listing | null>;
+    }): Promise<Creator | null>;
     /**
-     * Check if a payment token is supported
-     * @param token Token address
+     * Check if an address is a registered creator
+     * @param creatorAddress The address to check
      * @param provider JSON-RPC provider
      */
-    isTokenSupported(token: string, provider: {
+    isRegisteredCreator(creatorAddress: string, provider: {
         call: (tx: object) => Promise<string>;
     }): Promise<boolean>;
     /**
-     * Calculate platform fee for a given price
-     * Platform keeps 10%, Creator/Seller receives 90%
-     * @param price The sale price
-     */
-    calculateFee(price: bigint): {
-        fee: bigint;
-        sellerAmount: bigint;
-    };
-}
-
-/**
- * ZubariTipsProtocol - Micropayment tips for creators
- *
- * Handles ETH and ERC-20 token tips with platform fee distribution.
- * Supports individual tips, batch tips, and tip queries.
- */
-declare class ZubariTipsProtocol {
-    private readonly contractAddress;
-    private readonly chainId;
-    private readonly abi;
-    constructor(contractAddress: string, chainId: number);
-    /**
-     * Get the contract ABI
-     */
-    getAbi(): ({
-        inputs: {
-            internalType: string;
-            name: string;
-            type: string;
-        }[];
-        stateMutability: string;
-        type: string;
-        name?: undefined;
-        anonymous?: undefined;
-        outputs?: undefined;
-    } | {
-        inputs: {
-            internalType: string;
-            name: string;
-            type: string;
-        }[];
-        name: string;
-        type: string;
-        stateMutability?: undefined;
-        anonymous?: undefined;
-        outputs?: undefined;
-    } | {
-        anonymous: boolean;
-        inputs: {
-            indexed: boolean;
-            internalType: string;
-            name: string;
-            type: string;
-        }[];
-        name: string;
-        type: string;
-        stateMutability?: undefined;
-        outputs?: undefined;
-    } | {
-        inputs: {
-            internalType: string;
-            name: string;
-            type: string;
-        }[];
-        name: string;
-        outputs: {
-            components: {
-                internalType: string;
-                name: string;
-                type: string;
-            }[];
-            internalType: string;
-            name: string;
-            type: string;
-        }[];
-        stateMutability: string;
-        type: string;
-        anonymous?: undefined;
-    } | {
-        inputs: {
-            internalType: string;
-            name: string;
-            type: string;
-        }[];
-        name: string;
-        outputs: {
-            internalType: string;
-            name: string;
-            type: string;
-        }[];
-        stateMutability: string;
-        type: string;
-        anonymous?: undefined;
-    })[];
-    /**
-     * Get the contract address
-     */
-    getAddress(): string;
-    /**
-     * Send ETH tip to a creator
-     * @param recipient The recipient address
-     * @param message Optional tip message
+     * Create a new subscription plan
+     * @param plan The plan details
      * @param signer Wallet signer with sendTransaction method
-     * @param value ETH amount to tip (in wei)
      */
-    tipETH(recipient: string, message: string, signer: {
+    createPlan(plan: SubscriptionPlan, signer: {
         sendTransaction: (tx: object) => Promise<{
             hash: string;
         }>;
-    }, value: bigint): Promise<TxResult>;
+    }): Promise<string>;
     /**
-     * Send ERC-20 token tip to a creator
-     * @param recipient The recipient address
-     * @param token The ERC-20 token address
-     * @param amount The amount of tokens to tip
-     * @param message Optional tip message
+     * Update an existing plan's price and duration
+     * @param planId The plan ID to update
+     * @param newPrice New price (0 to keep current)
+     * @param newDurationDays New duration in days (0 to keep current)
      * @param signer Wallet signer
      */
-    tipToken(recipient: string, token: string, amount: bigint, message: string, signer: {
+    updatePlan(planId: string, newPrice: bigint, newDurationDays: number, signer: {
         sendTransaction: (tx: object) => Promise<{
             hash: string;
         }>;
     }): Promise<TxResult>;
     /**
-     * Send batch tips to multiple creators in a single transaction
-     * @param recipients Array of recipient addresses
-     * @param amounts Array of tip amounts (in wei)
-     * @param messages Array of tip messages
+     * Deactivate a subscription plan (only creator can do this)
+     * @param planId The plan ID to deactivate
      * @param signer Wallet signer
-     * @param value Total ETH to send
      */
-    sendBatchTips(recipients: string[], amounts: bigint[], messages: string[], signer: {
+    deactivatePlan(planId: string, signer: {
         sendTransaction: (tx: object) => Promise<{
             hash: string;
         }>;
-    }, value: bigint): Promise<TxResult>;
-    /**
-     * Get tip details by ID
-     * @param tipId The tip ID
-     * @param provider JSON-RPC provider
-     */
-    getTip(tipId: string, provider: {
-        call: (tx: object) => Promise<string>;
-    }): Promise<Tip | null>;
-    /**
-     * Get total tips received by an address
-     * @param address The address to query
-     * @param provider JSON-RPC provider
-     */
-    getTotalTipsReceived(address: string, provider: {
-        call: (tx: object) => Promise<string>;
-    }): Promise<bigint>;
+    }): Promise<TxResult>;
     /**
-     * Get platform fee in basis points
+     * Get a specific plan by ID
+     * @param planId The plan ID
      * @param provider JSON-RPC provider
      */
-    getPlatformFeeBps(provider: {
+    getPlan(planId: string, provider: {
         call: (tx: object) => Promise<string>;
-    }): Promise<number>;
+    }): Promise<SubscriptionPlan | null>;
     /**
-     * Get current tip counter
+     * Get all plan IDs for a creator
+     * @param creator The creator address
      * @param provider JSON-RPC provider
      */
-    getTipCounter(provider: {
+    getCreatorPlanIds(creator: string, provider: {
         call: (tx: object) => Promise<string>;
-    }): Promise<bigint>;
+    }): Promise<string[]>;
     /**
-     * Get treasury address
+     * Get all plans for a creator with full details
+     * @param creator The creator address
      * @param provider JSON-RPC provider
      */
-    getTreasury(provider: {
+    getCreatorPlans(creator: string, provider: {
         call: (tx: object) => Promise<string>;
-    }): Promise<string>;
-    /**
-     * Calculate platform fee for a given amount
-     * @param amount The tip amount
-     * @param feeBps Fee in basis points (default: 1000 = 10%)
-     * Platform keeps 10%, Creator receives 90%
-     */
-    calculateFee(amount: bigint, feeBps?: number): {
-        fee: bigint;
-        creatorAmount: bigint;
-    };
-}
-
-/**
- * ZubariSubscriptionProtocol - Recurring subscription payments
- *
- * Handles subscription plan creation, subscription management,
- * and verification of active subscriptions using the ZubariSubscription smart contract.
- */
-declare class ZubariSubscriptionProtocol {
-    private readonly contractAddress;
-    private readonly chainId;
-    private readonly abi;
-    constructor(contractAddress: string, chainId: number);
-    /**
-     * Get the contract ABI
-     */
-    getAbi(): ({
-        inputs: {
-            internalType: string;
-            name: string;
-            type: string;
-        }[];
-        stateMutability: string;
-        type: string;
-        name?: undefined;
-        anonymous?: undefined;
-        outputs?: undefined;
-    } | {
-        inputs: {
-            internalType: string;
-            name: string;
-            type: string;
-        }[];
-        name: string;
-        type: string;
-        stateMutability?: undefined;
-        anonymous?: undefined;
-        outputs?: undefined;
-    } | {
-        anonymous: boolean;
-        inputs: {
-            indexed: boolean;
-            internalType: string;
-            name: string;
-            type: string;
-        }[];
-        name: string;
-        type: string;
-        stateMutability?: undefined;
-        outputs?: undefined;
-    } | {
-        inputs: {
-            internalType: string;
-            name: string;
-            type: string;
-        }[];
-        name: string;
-        outputs: {
-            internalType: string;
-            name: string;
-            type: string;
-        }[];
-        stateMutability: string;
-        type: string;
-        anonymous?: undefined;
-    } | {
-        inputs: {
-            internalType: string;
-            name: string;
-            type: string;
-        }[];
-        name: string;
-        outputs: {
-            components: {
-                internalType: string;
-                name: string;
-                type: string;
-            }[];
-            internalType: string;
-            name: string;
-            type: string;
-        }[];
-        stateMutability: string;
-        type: string;
-        anonymous?: undefined;
-    })[];
-    /**
-     * Get the contract address
-     */
-    getAddress(): string;
-    /**
-     * Create a new subscription plan
-     * @param plan The plan details
-     * @param signer Wallet signer with sendTransaction method
-     */
-    createPlan(plan: SubscriptionPlan, signer: {
-        sendTransaction: (tx: object) => Promise<{
-            hash: string;
-        }>;
-    }): Promise<string>;
-    /**
-     * Deactivate a subscription plan (only creator can do this)
-     * @param planId The plan ID to deactivate
-     * @param signer Wallet signer
-     */
-    deactivatePlan(planId: string, signer: {
-        sendTransaction: (tx: object) => Promise<{
-            hash: string;
-        }>;
-    }): Promise<TxResult>;
+    }): Promise<SubscriptionPlan[]>;
     /**
      * Subscribe to a creator's plan
      * @param planId The plan ID to subscribe to
@@ -532,6 +215,17 @@ declare class ZubariSubscriptionProtocol {
             hash: string;
         }>;
     }, value?: bigint): Promise<TxResult>;
+    /**
+     * Prepare transaction data for subscription (for frontend signing)
+     * @param planId The plan ID to subscribe to
+     * @param months Number of months to subscribe
+     * @param value ETH value in wei
+     */
+    prepareSubscribe(planId: string, months: number, value: bigint): Promise<{
+        to: string;
+        data: string;
+        value: string;
+    }>;
     /**
      * Cancel an active subscription
      * @param subscriptionId The subscription ID to cancel
@@ -580,29 +274,13 @@ declare class ZubariSubscriptionProtocol {
         call: (tx: object) => Promise<string>;
     }): Promise<Subscription | null>;
     /**
-     * Get a specific plan by ID
-     * @param planId The plan ID
-     * @param provider JSON-RPC provider
-     */
-    getPlan(planId: string, provider: {
-        call: (tx: object) => Promise<string>;
-    }): Promise<SubscriptionPlan | null>;
-    /**
-     * Get all plan IDs for a creator
-     * @param creator The creator address
+     * Get all subscription IDs for a subscriber
+     * @param subscriber The subscriber address
      * @param provider JSON-RPC provider
      */
-    getCreatorPlanIds(creator: string, provider: {
+    getSubscriberSubscriptionIds(subscriber: string, provider: {
         call: (tx: object) => Promise<string>;
     }): Promise<string[]>;
-    /**
-     * Get all plans for a creator with full details
-     * @param creator The creator address
-     * @param provider JSON-RPC provider
-     */
-    getCreatorPlans(creator: string, provider: {
-        call: (tx: object) => Promise<string>;
-    }): Promise<SubscriptionPlan[]>;
     /**
      * Get platform fee in basis points
      * @param provider JSON-RPC provider
@@ -626,109 +304,31 @@ declare class ZubariSubscriptionProtocol {
         fee: bigint;
         creatorAmount: bigint;
     };
-}
-
-/**
- * ZubariPayoutsProtocol - Creator earnings management
- *
- * Handles earnings tracking, claiming, revenue splits,
- * and conversion to stablecoins.
- */
-declare class ZubariPayoutsProtocol {
-    private readonly contractAddress;
-    private readonly chainId;
-    private readonly apiBaseUrl;
-    private readonly apiClient;
-    constructor(contractAddress: string, chainId: number, apiBaseUrl?: string);
-    /**
-     * Get pending earnings breakdown for the current user via API
-     * Uses backend API which reads from contract/database
-     */
-    getPendingEarnings(authToken: string): Promise<EarningsBreakdown>;
-    /**
-     * Get earnings data from API (includes pending, total, breakdown, and recent payouts)
-     * Requires authentication token
-     */
-    getEarnings(authToken: string): Promise<EarningsResponse>;
-    /**
-     * Get payout history with pagination
-     * Requires authentication token
-     */
-    getPayoutHistory(authToken: string, page?: number, limit?: number): Promise<PayoutHistoryResponse>;
-    /**
-     * Get earnings breakdown by source with percentages
-     * Requires authentication token
-     */
-    getBreakdown(authToken: string): Promise<BreakdownResponse>;
-    /**
-     * Get current platform fee
-     */
-    getPlatformFee(): Promise<PlatformFeeResponse>;
-    /**
-     * Get historical earnings for a time period via API
-     */
-    getEarningsHistory(authToken: string, period?: 'day' | 'week' | 'month' | 'all'): Promise<EarningsBreakdown[]>;
-    /**
-     * Claim all pending earnings via API
-     * Requires authentication token and seed phrase
-     */
-    claimEarningsViaApi(authToken: string, seed: string): Promise<ClaimResult>;
-    /**
-     * Claim all pending earnings (direct contract call)
-     * Requires a signer with sendTransaction capability
-     */
-    claimEarnings(tokenAddress: string, signer: {
-        sendTransaction: (tx: object) => Promise<{
-            hash: string;
-        }>;
-    }): Promise<TxResult>;
-    /**
-     * Claim specific amount of earnings
-     * Requires a signer with sendTransaction capability
-     */
-    claimPartialEarnings(tokenAddress: string, amount: bigint, signer: {
-        sendTransaction: (tx: object) => Promise<{
-            hash: string;
-        }>;
-    }): Promise<TxResult>;
-    /**
-     * Setup revenue split with collaborators
-     * Basis points must sum to 10000 (100%)
-     * Requires a signer with sendTransaction capability
-     */
-    setupRevenueSplit(splits: RevenueSplit[], signer: {
-        sendTransaction: (tx: object) => Promise<{
-            hash: string;
-        }>;
-    }): Promise<TxResult>;
-    /**
-     * Get current revenue split configuration via API
-     */
-    getRevenueSplit(creatorAddress: string): Promise<RevenueSplit[]>;
-    /**
-     * Remove revenue split (creator gets 100%)
-     * Requires a signer with sendTransaction capability
-     */
-    removeRevenueSplit(signer: {
-        sendTransaction: (tx: object) => Promise<{
-            hash: string;
-        }>;
-    }): Promise<TxResult>;
     /**
-     * Convert earnings to stablecoin (USDT) via swap
-     * This will be implemented when SwapService is complete
+     * Calculate fee using on-chain values
+     * @param amount The amount
+     * @param provider JSON-RPC provider
      */
-    convertToStable(token: string, amount: bigint, swapService?: {
-        executeSwap: (params: object) => Promise<TxResult>;
-    }): Promise<TxResult>;
+    calculateFeeOnChain(amount: bigint, provider: {
+        call: (tx: object) => Promise<string>;
+    }): Promise<{
+        fee: bigint;
+        creatorAmount: bigint;
+    }>;
     /**
-     * Get the contract address
+     * Get treasury address
+     * @param provider JSON-RPC provider
      */
-    getContractAddress(): string;
+    getTreasury(provider: {
+        call: (tx: object) => Promise<string>;
+    }): Promise<string>;
     /**
-     * Get the chain ID
+     * Get payouts contract address
+     * @param provider JSON-RPC provider
      */
-    getChainId(): number;
+    getPayoutsContract(provider: {
+        call: (tx: object) => Promise<string>;
+    }): Promise<string>;
 }
 
-export { ZubariMarketProtocol, ZubariNFTProtocol, ZubariPayoutsProtocol, ZubariSubscriptionProtocol, ZubariTipsProtocol };
+export { ZubariSubscriptionV2Protocol };