@zubari/sdk 0.3.7 → 0.3.8

package/dist/PayoutsProtocol-B5z8SEA-.d.ts

@@ -0,0 +1,734 @@
+import { h as CreateVoucherParams, L as LazyMintVoucher, g as NFTMetadata, T as TxResult, j as ListingParams, i as NFT, B as BuyParams, k as Listing, o as Tip, S as SubscriptionPlan, a 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-CTyZlHKg.js';
+
+/**
+ * ZubariNFTProtocol - NFT creation and marketplace operations
+ *
+ * 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 NFT listings, purchases, and marketplace management
+ * with support for ETH and ERC-20 payment tokens.
+ */
+declare class ZubariMarketProtocol {
+    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;
+    /**
+     * List an NFT for sale
+     * @param params Listing parameters
+     * @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: {
+        sendTransaction: (tx: object) => Promise<{
+            hash: string;
+        }>;
+    }): Promise<TxResult>;
+    /**
+     * Cancel a listing
+     * @param listingId The listing ID to cancel
+     * @param signer Wallet signer
+     */
+    cancelListing(listingId: string, signer: {
+        sendTransaction: (tx: object) => Promise<{
+            hash: string;
+        }>;
+    }): Promise<TxResult>;
+    /**
+     * Update listing price
+     * @param listingId The listing ID
+     * @param newPrice New price
+     * @param signer Wallet signer
+     */
+    updatePrice(listingId: string, newPrice: bigint, signer: {
+        sendTransaction: (tx: object) => Promise<{
+            hash: string;
+        }>;
+    }): Promise<TxResult>;
+    /**
+     * Get listing details
+     * @param listingId The listing ID
+     * @param provider JSON-RPC provider
+     */
+    getListing(listingId: string, provider: {
+        call: (tx: object) => Promise<string>;
+    }): Promise<Listing | null>;
+    /**
+     * Check if a payment token is supported
+     * @param token Token address
+     * @param provider JSON-RPC provider
+     */
+    isTokenSupported(token: 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
+     * @param signer Wallet signer with sendTransaction method
+     * @param value ETH amount to tip (in wei)
+     */
+    tipETH(recipient: string, message: string, signer: {
+        sendTransaction: (tx: object) => Promise<{
+            hash: string;
+        }>;
+    }, value: bigint): Promise<TxResult>;
+    /**
+     * 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
+     * @param signer Wallet signer
+     */
+    tipToken(recipient: string, token: string, amount: bigint, message: string, 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
+     * @param signer Wallet signer
+     * @param value Total ETH to send
+     */
+    sendBatchTips(recipients: string[], amounts: bigint[], messages: 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>;
+    /**
+     * Get platform fee in basis points
+     * @param provider JSON-RPC provider
+     */
+    getPlatformFeeBps(provider: {
+        call: (tx: object) => Promise<string>;
+    }): Promise<number>;
+    /**
+     * Get current tip counter
+     * @param provider JSON-RPC provider
+     */
+    getTipCounter(provider: {
+        call: (tx: object) => Promise<string>;
+    }): Promise<bigint>;
+    /**
+     * Get treasury address
+     * @param provider JSON-RPC provider
+     */
+    getTreasury(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>;
+    /**
+     * Subscribe to a creator's plan
+     * @param planId The plan ID to subscribe to
+     * @param months Number of months to subscribe
+     * @param signer Wallet signer
+     * @param value ETH value to send (if paying with ETH)
+     */
+    subscribe(planId: string, months: number, signer: {
+        sendTransaction: (tx: object) => Promise<{
+            hash: string;
+        }>;
+    }, value?: bigint): Promise<TxResult>;
+    /**
+     * Cancel an active subscription
+     * @param subscriptionId The subscription ID to cancel
+     * @param signer Wallet signer
+     */
+    cancel(subscriptionId: string, signer: {
+        sendTransaction: (tx: object) => Promise<{
+            hash: string;
+        }>;
+    }): Promise<TxResult>;
+    /**
+     * Set auto-renew for a subscription
+     * @param subscriptionId The subscription ID
+     * @param autoRenew Whether to enable auto-renew
+     * @param signer Wallet signer
+     */
+    setAutoRenew(subscriptionId: string, autoRenew: boolean, signer: {
+        sendTransaction: (tx: object) => Promise<{
+            hash: string;
+        }>;
+    }): Promise<TxResult>;
+    /**
+     * Check if an address is subscribed to a creator
+     * @param subscriber The subscriber address
+     * @param creator The creator address
+     * @param provider JSON-RPC provider
+     */
+    isSubscribed(subscriber: string, creator: string, provider: {
+        call: (tx: object) => Promise<string>;
+    }): Promise<boolean>;
+    /**
+     * Get the active subscription ID between subscriber and creator
+     * @param subscriber The subscriber address
+     * @param creator The creator address
+     * @param provider JSON-RPC provider
+     */
+    getActiveSubscriptionId(subscriber: string, creator: string, provider: {
+        call: (tx: object) => Promise<string>;
+    }): Promise<string | null>;
+    /**
+     * Get subscription details by ID
+     * @param subscriptionId The subscription ID
+     * @param provider JSON-RPC provider
+     */
+    getSubscription(subscriptionId: string, provider: {
+        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
+     * @param provider JSON-RPC provider
+     */
+    getCreatorPlanIds(creator: 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
+     */
+    getPlatformFeeBps(provider: {
+        call: (tx: object) => Promise<string>;
+    }): Promise<number>;
+    /**
+     * Calculate the total cost for a subscription
+     * @param planPrice The plan price per period
+     * @param months Number of months
+     */
+    calculateSubscriptionCost(planPrice: bigint, months: number): bigint;
+    /**
+     * Calculate platform fee for a given amount
+     * @param amount The 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;
+    };
+}
+
+/**
+ * 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
+     */
+    convertToStable(token: string, amount: bigint, swapService?: {
+        executeSwap: (params: object) => Promise<TxResult>;
+    }): Promise<TxResult>;
+    /**
+     * Get the contract address
+     */
+    getContractAddress(): string;
+    /**
+     * Get the chain ID
+     */
+    getChainId(): number;
+}
+
+export { ZubariNFTProtocol as Z, ZubariMarketProtocol as a, ZubariTipsProtocol as b, ZubariSubscriptionProtocol as c, ZubariPayoutsProtocol as d };