@zubari/sdk 0.2.8 → 0.3.1

package/dist/protocols/index.mjs

@@ -42,18 +42,702 @@ var CURRENCY_ADDRESSES = {
   }
 };
 
+// src/services/ZubariApiClient.ts
+var ZubariApiClient = class {
+  config;
+  constructor(config) {
+    this.config = {
+      baseUrl: config.baseUrl.replace(/\/$/, ""),
+      // Remove trailing slash
+      timeout: config.timeout || 3e4,
+      authToken: config.authToken
+    };
+  }
+  /**
+   * Set the authentication token
+   */
+  setAuthToken(token) {
+    this.config.authToken = token;
+  }
+  /**
+   * Clear the authentication token
+   */
+  clearAuthToken() {
+    this.config.authToken = void 0;
+  }
+  /**
+   * Make an authenticated request to the API
+   */
+  async request(method, path, body) {
+    const headers = {
+      "Content-Type": "application/json"
+    };
+    if (this.config.authToken) {
+      headers["Authorization"] = `Bearer ${this.config.authToken}`;
+    }
+    const response = await fetch(`${this.config.baseUrl}${path}`, {
+      method,
+      headers,
+      body: body ? JSON.stringify(body) : void 0
+    });
+    if (!response.ok) {
+      const errorData = await response.json().catch(() => ({}));
+      throw new Error(errorData.error || `HTTP ${response.status}: ${response.statusText}`);
+    }
+    return response.json();
+  }
+  // ============ NFT Methods ============
+  /**
+   * Get all NFTs with optional filters
+   */
+  async getNFTs(filters) {
+    try {
+      const params = new URLSearchParams();
+      if (filters) {
+        Object.entries(filters).forEach(([key, value]) => {
+          if (value !== void 0) {
+            params.append(key, String(value));
+          }
+        });
+      }
+      const queryString = params.toString();
+      const path = `/api/nfts${queryString ? `?${queryString}` : ""}`;
+      return await this.request("GET", path);
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Failed to get NFTs"
+      };
+    }
+  }
+  /**
+   * Get a single NFT by ID
+   */
+  async getNFT(nftId) {
+    try {
+      const nft = await this.request("GET", `/api/nfts/${nftId}`);
+      return { success: true, nft };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Failed to get NFT"
+      };
+    }
+  }
+  /**
+   * Create a new NFT (lazy minted)
+   */
+  async createNFT(data, image) {
+    try {
+      const formData = new FormData();
+      formData.append("image", image);
+      formData.append("name", data.name);
+      if (data.description) formData.append("description", data.description);
+      formData.append("price", data.price);
+      formData.append("currency", data.currency);
+      if (data.royaltyBps !== void 0) formData.append("royaltyBps", String(data.royaltyBps));
+      if (data.attributes) formData.append("attributes", JSON.stringify(data.attributes));
+      if (data.externalUrl) formData.append("externalUrl", data.externalUrl);
+      const headers = {};
+      if (this.config.authToken) {
+        headers["Authorization"] = `Bearer ${this.config.authToken}`;
+      }
+      const response = await fetch(`${this.config.baseUrl}/api/nfts`, {
+        method: "POST",
+        headers,
+        body: formData
+      });
+      if (!response.ok) {
+        const errorData = await response.json().catch(() => ({}));
+        throw new Error(errorData.error || `HTTP ${response.status}`);
+      }
+      const nft = await response.json();
+      return { success: true, nft };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Failed to create NFT"
+      };
+    }
+  }
+  /**
+   * Create a voucher for an NFT (EIP-712 signed)
+   */
+  async createVoucher(nftId, params) {
+    try {
+      return await this.request("POST", `/api/nfts/${nftId}/voucher`, params);
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Failed to create voucher"
+      };
+    }
+  }
+  /**
+   * Redeem an NFT voucher (buy/mint)
+   */
+  async redeemVoucher(nftId, params) {
+    try {
+      return await this.request("POST", `/api/nfts/${nftId}/redeem`, params);
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Failed to redeem voucher"
+      };
+    }
+  }
+  /**
+   * Get voucher status for an NFT
+   */
+  async getVoucherStatus(nftId) {
+    try {
+      return await this.request("GET", `/api/nfts/${nftId}/voucher/status`);
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Failed to get voucher status"
+      };
+    }
+  }
+  // ============ Marketplace Methods ============
+  /**
+   * Get all active listings
+   */
+  async getListings(filters) {
+    try {
+      const params = new URLSearchParams();
+      if (filters) {
+        Object.entries(filters).forEach(([key, value]) => {
+          if (value !== void 0) {
+            params.append(key, String(value));
+          }
+        });
+      }
+      const queryString = params.toString();
+      const path = `/api/market/listings${queryString ? `?${queryString}` : ""}`;
+      return await this.request("GET", path);
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Failed to get listings"
+      };
+    }
+  }
+  /**
+   * List an NFT for sale
+   */
+  async listItem(params) {
+    try {
+      return await this.request("POST", "/api/market/list", params);
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Failed to list item"
+      };
+    }
+  }
+  /**
+   * Buy a listed NFT
+   */
+  async buyItem(params) {
+    try {
+      return await this.request("POST", "/api/market/buy", params);
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Failed to buy item"
+      };
+    }
+  }
+  /**
+   * Cancel a listing
+   */
+  async cancelListing(params) {
+    try {
+      return await this.request("POST", "/api/market/cancel", params);
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Failed to cancel listing"
+      };
+    }
+  }
+  /**
+   * Update listing price
+   */
+  async updateListingPrice(params) {
+    try {
+      return await this.request("PATCH", "/api/market/price", params);
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Failed to update price"
+      };
+    }
+  }
+  /**
+   * Get current user's listings
+   */
+  async getMyListings(filters) {
+    try {
+      const params = new URLSearchParams();
+      if (filters) {
+        Object.entries(filters).forEach(([key, value]) => {
+          if (value !== void 0) {
+            params.append(key, String(value));
+          }
+        });
+      }
+      const queryString = params.toString();
+      const path = `/api/market/my/listings${queryString ? `?${queryString}` : ""}`;
+      return await this.request("GET", path);
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Failed to get my listings"
+      };
+    }
+  }
+  /**
+   * Get marketplace statistics
+   */
+  async getMarketStats() {
+    try {
+      return await this.request("GET", "/api/market/stats");
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Failed to get market stats"
+      };
+    }
+  }
+  // ============ Tips Methods ============
+  /**
+   * Send a tip to a creator
+   */
+  async sendTip(params) {
+    try {
+      return await this.request("POST", "/api/tips", params);
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Failed to send tip"
+      };
+    }
+  }
+  /**
+   * Get tip statistics for current user
+   */
+  async getTipStats() {
+    try {
+      const data = await this.request("GET", "/api/tips/my/stats");
+      return { success: true, ...data };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Failed to get tip stats"
+      };
+    }
+  }
+  /**
+   * Get tips sent by current user
+   */
+  async getSentTips(filters) {
+    try {
+      const params = new URLSearchParams();
+      if (filters) {
+        Object.entries(filters).forEach(([key, value]) => {
+          if (value !== void 0) {
+            params.append(key, String(value));
+          }
+        });
+      }
+      const queryString = params.toString();
+      const path = `/api/tips/sent${queryString ? `?${queryString}` : ""}`;
+      const data = await this.request("GET", path);
+      return { success: true, ...data };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Failed to get sent tips"
+      };
+    }
+  }
+  /**
+   * Get tips received by current user
+   */
+  async getReceivedTips(filters) {
+    try {
+      const params = new URLSearchParams();
+      if (filters) {
+        Object.entries(filters).forEach(([key, value]) => {
+          if (value !== void 0) {
+            params.append(key, String(value));
+          }
+        });
+      }
+      const queryString = params.toString();
+      const path = `/api/tips/received${queryString ? `?${queryString}` : ""}`;
+      const data = await this.request("GET", path);
+      return { success: true, ...data };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Failed to get received tips"
+      };
+    }
+  }
+  /**
+   * Get a single tip by ID
+   */
+  async getTip(tipId) {
+    try {
+      const data = await this.request("GET", `/api/tips/${tipId}`);
+      return { success: true, tip: data.tip };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Failed to get tip"
+      };
+    }
+  }
+  /**
+   * Update tip status (for transaction confirmation)
+   */
+  async updateTipStatus(tipId, params) {
+    try {
+      const data = await this.request(
+        "PATCH",
+        `/api/tips/${tipId}/status`,
+        params
+      );
+      return { success: true, ...data };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Failed to update tip status"
+      };
+    }
+  }
+  // ============ Subscription Methods ============
+  /**
+   * Create a new subscription plan (creator only)
+   */
+  async createSubscriptionPlan(params) {
+    try {
+      return await this.request("POST", "/api/subscriptions/plans", params);
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Failed to create subscription plan"
+      };
+    }
+  }
+  /**
+   * Get current user's subscription plans
+   */
+  async getMySubscriptionPlans() {
+    try {
+      const data = await this.request("GET", "/api/subscriptions/plans");
+      return { success: true, plans: data.plans };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Failed to get subscription plans"
+      };
+    }
+  }
+  /**
+   * Get subscription plan by ID
+   */
+  async getSubscriptionPlan(planId) {
+    try {
+      const plan = await this.request(
+        "GET",
+        `/api/subscriptions/plans/${planId}`
+      );
+      return { success: true, plan };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Failed to get subscription plan"
+      };
+    }
+  }
+  /**
+   * Delete/deactivate subscription plan
+   */
+  async deleteSubscriptionPlan(planId) {
+    try {
+      const data = await this.request(
+        "DELETE",
+        `/api/subscriptions/plans/${planId}`
+      );
+      return { success: true, ...data };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Failed to delete subscription plan"
+      };
+    }
+  }
+  /**
+   * Subscribe to a plan
+   */
+  async subscribe(params) {
+    try {
+      return await this.request("POST", "/api/subscriptions/subscribe", params);
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Failed to subscribe"
+      };
+    }
+  }
+  /**
+   * Get current user's subscriptions (as subscriber)
+   */
+  async getMySubscriptions(filters) {
+    try {
+      const params = new URLSearchParams();
+      if (filters) {
+        Object.entries(filters).forEach(([key, value]) => {
+          if (value !== void 0) {
+            params.append(key, String(value));
+          }
+        });
+      }
+      const queryString = params.toString();
+      const path = `/api/subscriptions${queryString ? `?${queryString}` : ""}`;
+      const data = await this.request("GET", path);
+      return { success: true, ...data };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Failed to get subscriptions"
+      };
+    }
+  }
+  /**
+   * Get subscribers to current user's plans (as creator)
+   */
+  async getMySubscribers(filters) {
+    try {
+      const params = new URLSearchParams();
+      if (filters) {
+        Object.entries(filters).forEach(([key, value]) => {
+          if (value !== void 0) {
+            params.append(key, String(value));
+          }
+        });
+      }
+      const queryString = params.toString();
+      const path = `/api/subscriptions/subscribers${queryString ? `?${queryString}` : ""}`;
+      const data = await this.request("GET", path);
+      return { success: true, ...data };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Failed to get subscribers"
+      };
+    }
+  }
+  /**
+   * Cancel subscription
+   */
+  async cancelSubscription(subscriptionId) {
+    try {
+      const data = await this.request("DELETE", `/api/subscriptions/${subscriptionId}`);
+      return { success: true, ...data };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Failed to cancel subscription"
+      };
+    }
+  }
+  /**
+   * Create a subscription plan on-chain
+   */
+  async createSubscriptionPlanOnChain(params) {
+    try {
+      return await this.request("POST", "/api/subscriptions/contract/plans", params);
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Failed to create plan on-chain"
+      };
+    }
+  }
+  /**
+   * Subscribe to a plan on-chain
+   */
+  async subscribeOnChain(params) {
+    try {
+      return await this.request("POST", "/api/subscriptions/contract/subscribe", params);
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Failed to subscribe on-chain"
+      };
+    }
+  }
+  /**
+   * Cancel subscription on-chain
+   */
+  async cancelSubscriptionOnChain(subscriptionId, seed) {
+    try {
+      return await this.request(
+        "POST",
+        "/api/subscriptions/contract/cancel",
+        { subscriptionId, seed }
+      );
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Failed to cancel subscription on-chain"
+      };
+    }
+  }
+  /**
+   * Check if user is subscribed to a creator on-chain
+   */
+  async isSubscribed(subscriber, creator) {
+    try {
+      return await this.request(
+        "GET",
+        `/api/subscriptions/contract/is-subscribed?subscriber=${subscriber}&creator=${creator}`
+      );
+    } catch (error) {
+      return {
+        subscriber,
+        creator,
+        isSubscribed: false
+      };
+    }
+  }
+  /**
+   * Get subscription platform fee
+   */
+  async getSubscriptionPlatformFee() {
+    try {
+      return await this.request("GET", "/api/subscriptions/platform-fee");
+    } catch (error) {
+      return {
+        feeBps: 0,
+        feePercent: "0"
+      };
+    }
+  }
+  // ============ Payouts Methods ============
+  /**
+   * Get pending and claimed earnings for the authenticated user
+   */
+  async getEarnings() {
+    try {
+      const data = await this.request("GET", "/api/payouts/earnings");
+      return { success: true, ...data };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Failed to get earnings"
+      };
+    }
+  }
+  /**
+   * Claim pending earnings
+   */
+  async claimEarnings(params) {
+    try {
+      return await this.request("POST", "/api/payouts/claim", params);
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Failed to claim earnings"
+      };
+    }
+  }
+  /**
+   * Get payout history for the authenticated user
+   */
+  async getPayoutHistory(filters) {
+    try {
+      const params = new URLSearchParams();
+      if (filters) {
+        Object.entries(filters).forEach(([key, value]) => {
+          if (value !== void 0) {
+            params.append(key, String(value));
+          }
+        });
+      }
+      const queryString = params.toString();
+      const path = `/api/payouts/history${queryString ? `?${queryString}` : ""}`;
+      const data = await this.request("GET", path);
+      return { success: true, ...data };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Failed to get payout history"
+      };
+    }
+  }
+  /**
+   * Get earnings breakdown by source
+   */
+  async getEarningsBreakdown() {
+    try {
+      const data = await this.request("GET", "/api/payouts/breakdown");
+      return { success: true, ...data };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Failed to get earnings breakdown"
+      };
+    }
+  }
+  /**
+   * Get current platform fee for payouts
+   */
+  async getPayoutsPlatformFee() {
+    try {
+      return await this.request("GET", "/api/payouts/platform-fee");
+    } catch (error) {
+      return {
+        feeBps: 0,
+        feePercent: "0"
+      };
+    }
+  }
+};
+var DEFAULT_API_URL = process.env.NEXT_PUBLIC_API_URL || "https://ckgwifsxka.us-east-2.awsapprunner.com";
+var zubariApiClient = null;
+function getZubariApiClient(config) {
+  if (!zubariApiClient || config?.baseUrl && zubariApiClient["config"].baseUrl !== config.baseUrl) {
+    zubariApiClient = new ZubariApiClient({
+      baseUrl: config?.baseUrl || DEFAULT_API_URL,
+      timeout: config?.timeout,
+      authToken: config?.authToken
+    });
+  } else if (config?.authToken) {
+    zubariApiClient.setAuthToken(config.authToken);
+  }
+  return zubariApiClient;
+}
+
 // src/protocols/NFTProtocol.ts
 var ZubariNFTProtocol = class {
   contractAddress;
   _marketplaceAddress;
   chainId;
   network;
+  apiClient;
   nonceCounter = 0;
-  constructor(contractAddress, marketplaceAddress, chainId, network = "testnet") {
+  constructor(contractAddress, marketplaceAddress, chainId, network = "testnet", apiUrl) {
     this.contractAddress = contractAddress;
     this._marketplaceAddress = marketplaceAddress;
     this.chainId = chainId;
     this.network = network;
+    this.apiClient = getZubariApiClient(apiUrl ? { baseUrl: apiUrl } : void 0);
   }
   /**
    * Convert human-readable price to wei
@@ -170,52 +854,153 @@ var ZubariNFTProtocol = class {
   }
   /**
    * Redeem a lazy mint voucher to mint the NFT on-chain
+   * Uses the backend API which handles the on-chain transaction
    */
-  async redeemVoucher(voucher, _buyerAddress) {
+  async redeemVoucher(voucher, buyerAddress, nftId, authToken) {
     if (voucher.deadline < Math.floor(Date.now() / 1e3)) {
       throw new Error("Voucher has expired");
     }
-    return {
-      hash: "",
-      network: "ethereum",
-      status: "pending"
-    };
+    try {
+      const result = await this.apiClient.redeemVoucher(nftId, {
+        buyerAddress
+      });
+      if (result.success && result.transactionHash) {
+        return {
+          hash: result.transactionHash,
+          network: "ethereum",
+          status: "pending",
+          metadata: {
+            nftId: result.nftId,
+            tokenId: voucher.tokenId,
+            buyer: buyerAddress
+          }
+        };
+      }
+      throw new Error(result.error || "Failed to redeem voucher");
+    } catch (error) {
+      console.error("Failed to redeem voucher:", error);
+      throw new Error(`Voucher redemption failed: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
   }
   /**
-   * List an NFT for sale on the marketplace
+   * List an NFT for sale on the marketplace via backend API
    */
-  async listForSale(_params) {
-    return {
-      hash: "",
-      network: "ethereum",
-      status: "pending"
-    };
+  async listForSale(params, authToken) {
+    try {
+      const currency = params.paymentToken === ZERO_ADDRESS ? "ETH" : "USDT";
+      const result = await this.apiClient.listItem({
+        nftId: params.tokenId,
+        // Using tokenId as nftId
+        price: params.price.toString(),
+        currency,
+        duration: params.duration || 30 * 24 * 60 * 60
+        // 30 days default
+      });
+      if (result.success && result.listing) {
+        return {
+          hash: result.listing.id || "",
+          network: "ethereum",
+          status: "pending",
+          metadata: {
+            listingId: result.listing.id,
+            price: params.price.toString(),
+            tokenId: params.tokenId
+          }
+        };
+      }
+      throw new Error(result.error || "Failed to list NFT");
+    } catch (error) {
+      console.error("Failed to list NFT:", error);
+      throw new Error(`Listing failed: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
   }
   /**
-   * Buy an NFT from the marketplace
+   * Buy an NFT from the marketplace via backend API
    */
-  async buyNFT(_listingId, _price) {
-    return {
-      hash: "",
-      network: "ethereum",
-      status: "pending"
-    };
+  async buyNFT(listingId, price, buyerAddress) {
+    try {
+      const result = await this.apiClient.buyItem({
+        listingId,
+        buyerAddress
+      });
+      if (result.success && result.transactionHash) {
+        return {
+          hash: result.transactionHash,
+          network: "ethereum",
+          status: "pending",
+          metadata: {
+            listingId,
+            price: price.toString(),
+            buyer: buyerAddress
+          }
+        };
+      }
+      throw new Error(result.error || "Failed to buy NFT");
+    } catch (error) {
+      console.error("Failed to buy NFT:", error);
+      throw new Error(`Purchase failed: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
   }
   /**
    * Transfer an NFT to another address
+   * Note: This requires direct contract interaction via wallet
    */
-  async transfer(_tokenId, _to) {
-    return {
-      hash: "",
-      network: "ethereum",
-      status: "pending"
-    };
+  async transfer(tokenId, to, from, signer) {
+    try {
+      const functionSelector = "0x23b872dd";
+      const encodedFrom = from.toLowerCase().replace("0x", "").padStart(64, "0");
+      const encodedTo = to.toLowerCase().replace("0x", "").padStart(64, "0");
+      const encodedTokenId = BigInt(tokenId).toString(16).padStart(64, "0");
+      const data = `${functionSelector}${encodedFrom}${encodedTo}${encodedTokenId}`;
+      const tx = await signer.sendTransaction({
+        to: this.contractAddress,
+        data,
+        value: "0x0"
+      });
+      return {
+        hash: tx.hash,
+        network: "ethereum",
+        status: "pending",
+        metadata: {
+          tokenId,
+          from,
+          to
+        }
+      };
+    } catch (error) {
+      console.error("Failed to transfer NFT:", error);
+      throw new Error(`Transfer failed: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
   }
   /**
-   * Get NFTs owned by an address
+   * Get NFTs owned by an address via backend API
    */
-  async getOwnedNFTs(_address) {
-    return [];
+  async getOwnedNFTs(address) {
+    try {
+      const result = await this.apiClient.getNFTs({ ownerId: address });
+      if (result.success && result.nfts) {
+        return result.nfts.map((nft) => ({
+          tokenId: nft.tokenId || nft.id,
+          contractAddress: nft.contractAddress || this.contractAddress,
+          owner: nft.ownerId || address,
+          creator: nft.creatorId || "",
+          uri: nft.imageUrl || nft.animationUrl || "",
+          metadata: nft.name ? {
+            name: nft.name,
+            description: nft.description || "",
+            image: nft.imageUrl || "",
+            royaltyBps: 0
+            // Default royalty, actual value from contract
+          } : void 0,
+          isLazyMinted: !nft.tokenId
+          // If no tokenId, it's lazy minted
+        }));
+      }
+      return [];
+    } catch (error) {
+      console.error("Failed to get owned NFTs:", error);
+      return [];
+    }
   }
   /**
    * Generate a random tokenId (32 bytes hex)
@@ -3134,26 +3919,65 @@ var ZubariSubscriptionProtocol = class {
 };
 
 // src/protocols/PayoutsProtocol.ts
+var PAYOUTS_SELECTORS = {
+  getEarningsBreakdown: "0xd4e9329c",
+  // getEarningsBreakdown(address)
+  claimEarnings: "0x48c54b9d",
+  // claimEarnings(address)
+  claimPartialEarnings: "0x7e3bfb5a",
+  // claimPartialEarnings(address,uint256)
+  setRevenueSplit: "0x92a8e3f5",
+  // setRevenueSplit((address,uint256)[])
+  getRevenueSplit: "0x6c8a4fd0",
+  // getRevenueSplit(address)
+  removeRevenueSplit: "0x8a4e3c5b"
+  // removeRevenueSplit()
+};
 var ZubariPayoutsProtocol = class {
   contractAddress;
   chainId;
   apiBaseUrl;
+  apiClient;
   constructor(contractAddress, chainId, apiBaseUrl) {
     this.contractAddress = contractAddress;
     this.chainId = chainId;
     this.apiBaseUrl = apiBaseUrl || "https://ckgwifsxka.us-east-2.awsapprunner.com";
+    this.apiClient = getZubariApiClient({ baseUrl: this.apiBaseUrl });
   }
   /**
-   * Get pending earnings breakdown for the current user (on-chain)
+   * Get pending earnings breakdown for the current user via API
+   * Uses backend API which reads from contract/database
    */
-  async getPendingEarnings() {
-    return {
-      tips: BigInt(0),
-      subscriptions: BigInt(0),
-      nftSales: BigInt(0),
-      royalties: BigInt(0),
-      total: BigInt(0)
-    };
+  async getPendingEarnings(authToken) {
+    try {
+      const response = await this.apiClient.getEarnings();
+      if (response.success && response.earningsBreakdown) {
+        const breakdown = response.earningsBreakdown;
+        return {
+          tips: BigInt(breakdown.tips || "0"),
+          subscriptions: BigInt(breakdown.subscriptions || "0"),
+          nftSales: BigInt(breakdown.nftSales || "0"),
+          royalties: BigInt(breakdown.royalties || "0"),
+          total: BigInt(breakdown.tips || "0") + BigInt(breakdown.subscriptions || "0") + BigInt(breakdown.nftSales || "0") + BigInt(breakdown.royalties || "0")
+        };
+      }
+      return {
+        tips: BigInt(0),
+        subscriptions: BigInt(0),
+        nftSales: BigInt(0),
+        royalties: BigInt(0),
+        total: BigInt(0)
+      };
+    } catch (error) {
+      console.error("Failed to get pending earnings:", error);
+      return {
+        tips: BigInt(0),
+        subscriptions: BigInt(0),
+        nftSales: BigInt(0),
+        royalties: BigInt(0),
+        total: BigInt(0)
+      };
+    }
   }
   /**
    * Get earnings data from API (includes pending, total, breakdown, and recent payouts)
@@ -3225,10 +4049,30 @@ var ZubariPayoutsProtocol = class {
     return response.json();
   }
   /**
-   * Get historical earnings for a time period
+   * Get historical earnings for a time period via API
    */
-  async getEarningsHistory(period = "all") {
-    return [];
+  async getEarningsHistory(authToken, period = "all") {
+    try {
+      const response = await this.apiClient.getPayoutHistory({
+        limit: period === "day" ? 24 : period === "week" ? 7 : period === "month" ? 30 : 100
+      });
+      if (response.success && response.payouts) {
+        return response.payouts.map((payout) => ({
+          tips: BigInt(0),
+          // Individual payouts don't have breakdown
+          subscriptions: BigInt(0),
+          nftSales: BigInt(0),
+          royalties: BigInt(0),
+          total: BigInt(payout.amount || "0"),
+          timestamp: payout.createdAt,
+          status: payout.status
+        }));
+      }
+      return [];
+    } catch (error) {
+      console.error("Failed to get earnings history:", error);
+      return [];
+    }
   }
   /**
    * Claim all pending earnings via API
@@ -3251,32 +4095,62 @@ var ZubariPayoutsProtocol = class {
   }
   /**
    * Claim all pending earnings (direct contract call)
+   * Requires a signer with sendTransaction capability
    */
-  async claimEarnings() {
-    return {
-      hash: "",
-      network: "ethereum",
-      status: "pending"
-    };
+  async claimEarnings(tokenAddress, signer) {
+    try {
+      const encodedToken = tokenAddress.toLowerCase().replace("0x", "").padStart(64, "0");
+      const data = `${PAYOUTS_SELECTORS.claimEarnings}${encodedToken}`;
+      const tx = await signer.sendTransaction({
+        to: this.contractAddress,
+        data,
+        value: "0x0"
+      });
+      return {
+        hash: tx.hash,
+        network: "ethereum",
+        status: "pending",
+        metadata: { token: tokenAddress }
+      };
+    } catch (error) {
+      console.error("Failed to claim earnings:", error);
+      throw new Error(`Claim failed: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
   }
   /**
    * Claim specific amount of earnings
+   * Requires a signer with sendTransaction capability
    */
-  async claimPartialEarnings(amount) {
+  async claimPartialEarnings(tokenAddress, amount, signer) {
     if (amount <= 0n) {
       throw new Error("Amount must be greater than 0");
     }
-    return {
-      hash: "",
-      network: "ethereum",
-      status: "pending"
-    };
+    try {
+      const encodedToken = tokenAddress.toLowerCase().replace("0x", "").padStart(64, "0");
+      const encodedAmount = amount.toString(16).padStart(64, "0");
+      const data = `${PAYOUTS_SELECTORS.claimPartialEarnings}${encodedToken}${encodedAmount}`;
+      const tx = await signer.sendTransaction({
+        to: this.contractAddress,
+        data,
+        value: "0x0"
+      });
+      return {
+        hash: tx.hash,
+        network: "ethereum",
+        status: "pending",
+        metadata: { token: tokenAddress, amount: amount.toString() }
+      };
+    } catch (error) {
+      console.error("Failed to claim partial earnings:", error);
+      throw new Error(`Partial claim failed: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
   }
   /**
    * Setup revenue split with collaborators
    * Basis points must sum to 10000 (100%)
+   * Requires a signer with sendTransaction capability
    */
-  async setupRevenueSplit(splits) {
+  async setupRevenueSplit(splits, signer) {
     const totalBps = splits.reduce((sum, split) => sum + split.basisPoints, 0);
     if (totalBps !== 1e4) {
       throw new Error("Revenue splits must sum to 100% (10000 basis points)");
@@ -3289,40 +4163,98 @@ var ZubariPayoutsProtocol = class {
         throw new Error("Each split must have a valid recipient address");
       }
     }
-    return {
-      hash: "",
-      network: "ethereum",
-      status: "pending"
-    };
+    try {
+      const offset = "0".padStart(64, "0").slice(-64);
+      const arrayLength = splits.length.toString(16).padStart(64, "0");
+      let encodedSplits = "";
+      for (const split of splits) {
+        const encodedRecipient = split.recipient.toLowerCase().replace("0x", "").padStart(64, "0");
+        const encodedBps = split.basisPoints.toString(16).padStart(64, "0");
+        encodedSplits += encodedRecipient + encodedBps;
+      }
+      const data = `${PAYOUTS_SELECTORS.setRevenueSplit}${"0000000000000000000000000000000000000000000000000000000000000020"}${arrayLength}${encodedSplits}`;
+      const tx = await signer.sendTransaction({
+        to: this.contractAddress,
+        data,
+        value: "0x0"
+      });
+      return {
+        hash: tx.hash,
+        network: "ethereum",
+        status: "pending",
+        metadata: { splits }
+      };
+    } catch (error) {
+      console.error("Failed to setup revenue split:", error);
+      throw new Error(`Revenue split setup failed: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
   }
   /**
-   * Get current revenue split configuration
+   * Get current revenue split configuration via API
    */
-  async getRevenueSplit() {
-    return [];
+  async getRevenueSplit(creatorAddress) {
+    try {
+      const response = await fetch(`${this.apiBaseUrl}/api/payouts/revenue-split/${creatorAddress}`, {
+        headers: { "Content-Type": "application/json" }
+      });
+      if (response.ok) {
+        const data = await response.json();
+        if (data.success && data.splits) {
+          return data.splits;
+        }
+      }
+      return [];
+    } catch (error) {
+      console.error("Failed to get revenue split:", error);
+      return [];
+    }
   }
   /**
    * Remove revenue split (creator gets 100%)
+   * Requires a signer with sendTransaction capability
    */
-  async removeRevenueSplit() {
-    return {
-      hash: "",
-      network: "ethereum",
-      status: "pending"
-    };
+  async removeRevenueSplit(signer) {
+    try {
+      const data = PAYOUTS_SELECTORS.removeRevenueSplit;
+      const tx = await signer.sendTransaction({
+        to: this.contractAddress,
+        data,
+        value: "0x0"
+      });
+      return {
+        hash: tx.hash,
+        network: "ethereum",
+        status: "pending"
+      };
+    } catch (error) {
+      console.error("Failed to remove revenue split:", error);
+      throw new Error(`Remove revenue split failed: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
   }
   /**
-   * Convert earnings to stablecoin (USDT)
+   * Convert earnings to stablecoin (USDT) via swap
+   * This will be implemented when SwapService is complete
    */
-  async convertToStable(token, amount) {
+  async convertToStable(token, amount, swapService) {
     if (amount <= 0n) {
       throw new Error("Amount must be greater than 0");
     }
-    return {
-      hash: "",
-      network: "ethereum",
-      status: "pending"
-    };
+    if (!swapService) {
+      throw new Error("SwapService required for conversion. Import and pass SwapService instance.");
+    }
+    try {
+      return await swapService.executeSwap({
+        tokenIn: token,
+        tokenOut: "0xdAC17F958D2ee523a2206206994597C13D831ec7",
+        // USDT mainnet
+        amountIn: amount,
+        slippageBps: 50
+        // 0.5% slippage
+      });
+    } catch (error) {
+      console.error("Failed to convert to stable:", error);
+      throw new Error(`Conversion failed: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
   }
   /**
    * Get the contract address