@zubari/sdk 0.1.29 → 0.2.0

package/dist/protocols/index.d.mts

@@ -1,4 +1,4 @@
-import { c as NFTMetadata, L as LazyMintVoucher, b as TxResult, e as ListingParams, d as NFT, B as BuyParams, f as Listing, g as TipData, h as TipResult, i as TipStats, j as SubscriptionPlan, k as Subscription, E as EarningsBreakdown, R as RevenueSplit } from '../index-IPLQBUaD.mjs';
+import { C as CreateVoucherParams, L as LazyMintVoucher, e as NFTMetadata, b 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, R as RevenueSplit } from '../index-Be7yLGAO.mjs';
 
 /**
  * ZubariNFTProtocol - NFT creation and marketplace operations
@@ -10,12 +10,42 @@ declare class ZubariNFTProtocol {
     private readonly contractAddress;
     private readonly _marketplaceAddress;
     private readonly chainId;
-    constructor(contractAddress: string, marketplaceAddress: string, chainId: number);
+    private readonly network;
+    private nonceCounter;
+    constructor(contractAddress: string, marketplaceAddress: string, chainId: number, network?: 'testnet' | 'mainnet');
+    /**
+     * 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(metadata: NFTMetadata, creatorAddress: string, signer: {
+    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>;
     /**
@@ -203,89 +233,389 @@ declare class ZubariMarketProtocol {
  * ZubariTipsProtocol - Micropayment tips for creators
  *
  * Handles ETH and ERC-20 token tips with platform fee distribution.
- * Supports gasless tips via ERC-4337 when enabled.
+ * Supports individual tips, batch tips, and tip queries.
  */
 declare class ZubariTipsProtocol {
     private readonly contractAddress;
     private readonly chainId;
-    private readonly gaslessEnabled;
-    constructor(contractAddress: string, chainId: number, gaslessEnabled?: boolean);
+    private readonly abi;
+    constructor(contractAddress: string, chainId: number);
     /**
-     * Send a tip to a creator
+     * Get the contract ABI
      */
-    sendTip(tip: TipData): Promise<TipResult>;
+    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 tips to multiple creators in a single transaction
+     * 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
      */
-    sendBatchTips(tips: TipData[]): Promise<TipResult[]>;
+    tipToken(recipient: string, token: string, amount: bigint, message: string, signer: {
+        sendTransaction: (tx: object) => Promise<{
+            hash: string;
+        }>;
+    }): Promise<TxResult>;
     /**
-     * Get tips received by an address
+     * 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
      */
-    getTipsReceived(address: string): Promise<TipResult[]>;
+    sendBatchTips(recipients: string[], amounts: bigint[], messages: string[], signer: {
+        sendTransaction: (tx: object) => Promise<{
+            hash: string;
+        }>;
+    }, value: bigint): Promise<TxResult>;
     /**
-     * Get tips sent by an address
+     * Get tip details by ID
+     * @param tipId The tip ID
+     * @param provider JSON-RPC provider
      */
-    getTipsSent(address: string): Promise<TipResult[]>;
+    getTip(tipId: string, provider: {
+        call: (tx: object) => Promise<string>;
+    }): Promise<Tip | null>;
     /**
-     * Get tip statistics for a creator
+     * Get total tips received by an address
+     * @param address The address to query
+     * @param provider JSON-RPC provider
      */
-    getCreatorTipStats(creator: string): Promise<TipStats>;
+    getTotalTipsReceived(address: string, provider: {
+        call: (tx: object) => Promise<string>;
+    }): Promise<bigint>;
     /**
      * Get platform fee in basis points
+     * @param provider JSON-RPC provider
      */
-    getPlatformFeeBps(): number;
+    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: 300 = 3%)
+     */
+    calculateFee(amount: bigint, feeBps?: number): {
+        fee: bigint;
+        creatorAmount: bigint;
+    };
 }
 
 /**
  * ZubariSubscriptionProtocol - Recurring subscription payments
  *
  * Handles subscription plan creation, subscription management,
- * and verification of active subscriptions.
+ * 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): Promise<string>;
+    createPlan(plan: SubscriptionPlan, signer: {
+        sendTransaction: (tx: object) => Promise<{
+            hash: string;
+        }>;
+    }): Promise<string>;
     /**
-     * Update an existing subscription plan
+     * Deactivate a subscription plan (only creator can do this)
+     * @param planId The plan ID to deactivate
+     * @param signer Wallet signer
      */
-    updatePlan(planId: string, updates: Partial<SubscriptionPlan>): Promise<TxResult>;
+    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(creator: string, planId: string, months?: number): Promise<Subscription>;
+    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
      */
-    cancel(subscriptionId: string): Promise<TxResult>;
+    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(creator: string, subscriber?: string): Promise<boolean>;
+    isSubscribed(subscriber: string, creator: string, provider: {
+        call: (tx: object) => Promise<string>;
+    }): Promise<boolean>;
     /**
-     * Get active subscriptions for a subscriber
+     * Get the active subscription ID between subscriber and creator
+     * @param subscriber The subscriber address
+     * @param creator The creator address
+     * @param provider JSON-RPC provider
      */
-    getActiveSubscriptions(subscriber?: string): Promise<Subscription[]>;
+    getActiveSubscriptionId(subscriber: string, creator: string, provider: {
+        call: (tx: object) => Promise<string>;
+    }): Promise<string | null>;
     /**
-     * Get all subscribers for a creator
+     * Get subscription details by ID
+     * @param subscriptionId The subscription ID
+     * @param provider JSON-RPC provider
      */
-    getSubscribers(creator: string): Promise<Subscription[]>;
+    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): Promise<SubscriptionPlan | null>;
+    getPlan(planId: string, provider: {
+        call: (tx: object) => Promise<string>;
+    }): Promise<SubscriptionPlan | null>;
     /**
-     * Get all plans for a creator
+     * 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): Promise<SubscriptionPlan[]>;
+    getCreatorPlans(creator: string, provider: {
+        call: (tx: object) => Promise<string>;
+    }): Promise<SubscriptionPlan[]>;
     /**
-     * Generate a unique plan ID
+     * Get platform fee in basis points
+     * @param provider JSON-RPC provider
      */
-    private generatePlanId;
+    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
+     */
+    calculateFee(amount: bigint, feeBps?: number): {
+        fee: bigint;
+        creatorAmount: bigint;
+    };
 }
 
 /**