@zubari/sdk 0.1.29 → 0.2.0

package/dist/index.js

@@ -206,9 +206,30 @@ var NFT_VOUCHER_TYPES = {
     { name: "uri", type: "string" },
     { name: "creator", type: "address" },
     { name: "royaltyBps", type: "uint256" },
-    { name: "deadline", type: "uint256" }
+    { name: "deadline", type: "uint256" },
+    // Pricing fields
+    { name: "price", type: "uint256" },
+    { name: "currency", type: "address" },
+    { name: "nonce", type: "uint256" },
+    // Watermarking fields
+    { name: "contentHash", type: "bytes32" },
+    { name: "userId", type: "bytes32" },
+    { name: "watermarkTimestamp", type: "uint256" },
+    { name: "sessionId", type: "bytes32" }
   ]
 };
+var CURRENCY_ADDRESSES = {
+  testnet: {
+    ETH: ZERO_ADDRESS,
+    USDT: "0xaA8E23Fb1079EA71e0a56F48a2aA51851D8433D0"
+    // USDT on Sepolia
+  },
+  mainnet: {
+    ETH: ZERO_ADDRESS,
+    USDT: "0xdAC17F958D2ee523a2206206994597C13D831ec7"
+    // USDT on Ethereum
+  }
+};
 function getContractAddresses(network) {
   return ZUBARI_CONTRACTS[network];
 }
@@ -2313,28 +2334,86 @@ var ZubariNFTProtocol = class {
   contractAddress;
   _marketplaceAddress;
   chainId;
-  constructor(contractAddress, marketplaceAddress, chainId) {
+  network;
+  nonceCounter = 0;
+  constructor(contractAddress, marketplaceAddress, chainId, network = "testnet") {
     this.contractAddress = contractAddress;
     this._marketplaceAddress = marketplaceAddress;
     this.chainId = chainId;
+    this.network = network;
+  }
+  /**
+   * 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)
+   */
+  priceToWei(price, currency) {
+    const decimals = currency === "ETH" ? 18 : 6;
+    const [whole, fraction = ""] = price.split(".");
+    const paddedFraction = fraction.padEnd(decimals, "0").slice(0, decimals);
+    const wei = whole + paddedFraction;
+    return wei.replace(/^0+/, "") || "0";
+  }
+  /**
+   * Get currency address for the configured network
+   */
+  getCurrencyAddress(currency) {
+    return CURRENCY_ADDRESSES[this.network][currency];
+  }
+  /**
+   * Generate a unique nonce
+   */
+  generateNonce() {
+    return Date.now() * 1e3 + this.nonceCounter++;
+  }
+  /**
+   * Pad string to bytes32 format
+   */
+  toBytes32(value) {
+    if (value.startsWith("0x")) {
+      return value.padEnd(66, "0");
+    }
+    const hex = Buffer.from(value).toString("hex");
+    return "0x" + hex.padEnd(64, "0");
   }
   /**
    * 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)
    */
-  async createLazyMintVoucher(metadata, creatorAddress, signer) {
+  async createLazyMintVoucher(params, signer) {
+    const { metadata, creatorAddress, price, currency, nonce, watermarking } = params;
     if (metadata.royaltyBps > PLATFORM_CONFIG.maxRoyaltyBps) {
       throw new Error(`Royalty cannot exceed ${PLATFORM_CONFIG.maxRoyaltyBps / 100}%`);
     }
+    if (!price || parseFloat(price) <= 0) {
+      throw new Error("Price must be greater than 0");
+    }
     const tokenId = this.generateTokenId();
     const deadline = Math.floor(Date.now() / 1e3) + PLATFORM_CONFIG.voucherValiditySecs;
+    const priceInWei = this.priceToWei(price, currency);
+    const currencyAddress = this.getCurrencyAddress(currency);
+    const voucherNonce = nonce ?? this.generateNonce();
+    const watermarkTimestamp = watermarking ? Math.floor(Date.now() / 1e3) : 0;
+    const contentHash = watermarking ? this.toBytes32(watermarking.contentHash) : ZERO_ADDRESS.replace("0x", "0x" + "0".repeat(64)).slice(0, 66);
+    const userId = watermarking ? this.toBytes32(watermarking.userId) : ZERO_ADDRESS.replace("0x", "0x" + "0".repeat(64)).slice(0, 66);
+    const sessionId = watermarking ? this.toBytes32(watermarking.sessionId) : ZERO_ADDRESS.replace("0x", "0x" + "0".repeat(64)).slice(0, 66);
     const voucherData = {
       tokenId,
       uri: metadata.image,
       // Will be IPFS URI
       creator: creatorAddress,
       royaltyBps: metadata.royaltyBps,
-      deadline
+      deadline,
+      price: priceInWei,
+      currency: currencyAddress,
+      nonce: voucherNonce,
+      contentHash,
+      userId,
+      watermarkTimestamp,
+      sessionId
     };
     const domain = {
       ...NFT_VOUCHER_DOMAIN,
@@ -2343,10 +2422,36 @@ var ZubariNFTProtocol = class {
     };
     const signature = await signer.signTypedData(domain, NFT_VOUCHER_TYPES, voucherData);
     return {
-      ...voucherData,
-      signature
+      tokenId,
+      uri: metadata.image,
+      creator: creatorAddress,
+      royaltyBps: metadata.royaltyBps,
+      deadline,
+      signature,
+      price: priceInWei,
+      currency: currencyAddress,
+      nonce: voucherNonce,
+      contentHash: watermarking ? contentHash : void 0,
+      userId: watermarking ? userId : void 0,
+      watermarkTimestamp: watermarking ? watermarkTimestamp : void 0,
+      sessionId: watermarking ? sessionId : void 0
     };
   }
+  /**
+   * @deprecated Use createLazyMintVoucher(params, signer) instead
+   * Legacy method for backward compatibility
+   */
+  async createLazyMintVoucherLegacy(metadata, creatorAddress, signer) {
+    return this.createLazyMintVoucher(
+      {
+        metadata,
+        creatorAddress,
+        price: "0.01",
+        currency: "ETH"
+      },
+      signer
+    );
+  }
   /**
    * Redeem a lazy mint voucher to mint the NFT on-chain
    */
@@ -3294,187 +3399,2021 @@ var ZubariMarketProtocol = class {
   }
 };
 
-// src/protocols/TipsProtocol.ts
-var ZubariTipsProtocol = class {
-  contractAddress;
-  chainId;
-  gaslessEnabled;
-  constructor(contractAddress, chainId, gaslessEnabled = false) {
-    this.contractAddress = contractAddress;
-    this.chainId = chainId;
-    this.gaslessEnabled = gaslessEnabled;
-  }
-  /**
-   * Send a tip to a creator
-   */
-  async sendTip(tip) {
-    const { recipient, amount, token, message } = tip;
-    const platformFee = amount * BigInt(PLATFORM_CONFIG.tipFeeBps) / BigInt(1e4);
-    const creatorAmount = amount - platformFee;
-    if (amount <= 0n) {
-      throw new Error("Tip amount must be greater than 0");
-    }
-    const txResult = {
-      hash: ""};
-    return {
-      txHash: txResult.hash,
-      tipId: "",
-      // Will be returned from contract event
-      recipient,
-      amount: creatorAmount,
-      platformFee,
-      timestamp: Math.floor(Date.now() / 1e3)
-    };
-  }
-  /**
-   * Send tips to multiple creators in a single transaction
-   */
-  async sendBatchTips(tips) {
-    if (tips.length === 0) {
-      throw new Error("At least one tip is required");
-    }
-    tips.reduce((sum, tip) => sum + tip.amount, BigInt(0));
-    return tips.map((tip) => ({
-      txHash: "",
-      tipId: "",
-      recipient: tip.recipient,
-      amount: tip.amount - tip.amount * BigInt(PLATFORM_CONFIG.tipFeeBps) / BigInt(1e4),
-      platformFee: tip.amount * BigInt(PLATFORM_CONFIG.tipFeeBps) / BigInt(1e4),
-      timestamp: Math.floor(Date.now() / 1e3)
-    }));
-  }
-  /**
-   * Get tips received by an address
-   */
-  async getTipsReceived(address) {
-    return [];
-  }
-  /**
-   * Get tips sent by an address
-   */
-  async getTipsSent(address) {
-    return [];
-  }
-  /**
-   * Get tip statistics for a creator
-   */
-  async getCreatorTipStats(creator) {
-    return {
-      totalReceived: BigInt(0),
-      tipCount: 0,
-      uniqueTippers: 0
-    };
-  }
-  /**
-   * Get platform fee in basis points
-   */
-  getPlatformFeeBps() {
-    return PLATFORM_CONFIG.tipFeeBps;
-  }
-};
-
-// src/protocols/SubscriptionProtocol.ts
-var ZubariSubscriptionProtocol = class {
-  contractAddress;
-  chainId;
-  constructor(contractAddress, chainId) {
-    this.contractAddress = contractAddress;
-    this.chainId = chainId;
-  }
-  /**
-   * Create a new subscription plan
-   */
-  async createPlan(plan) {
-    if (!plan.name || plan.name.length === 0) {
-      throw new Error("Plan name is required");
-    }
-    if (plan.price <= 0n) {
-      throw new Error("Plan price must be greater than 0");
-    }
-    if (plan.duration <= 0) {
-      throw new Error("Plan duration must be greater than 0");
-    }
-    const planId = this.generatePlanId(plan.name);
-    return planId;
-  }
-  /**
-   * Update an existing subscription plan
-   */
-  async updatePlan(planId, updates) {
-    return {
-      hash: "",
-      network: "ethereum",
-      status: "pending"
-    };
-  }
-  /**
-   * Subscribe to a creator's plan
-   */
-  async subscribe(creator, planId, months = 1) {
-    if (months <= 0) {
-      throw new Error("Subscription duration must be at least 1 month");
-    }
-    const now = Math.floor(Date.now() / 1e3);
-    const durationSeconds = months * 30 * 24 * 60 * 60;
-    return {
-      subscriptionId: "",
-      planId,
-      creator,
-      subscriber: "",
-      // Current user address
-      startTime: now,
-      endTime: now + durationSeconds,
-      autoRenew: false,
-      status: "active"
-    };
-  }
-  /**
-   * Cancel an active subscription
-   */
-  async cancel(subscriptionId) {
-    return {
-      hash: "",
-      network: "ethereum",
-      status: "pending"
-    };
-  }
-  /**
-   * Check if an address is subscribed to a creator
-   */
-  async isSubscribed(creator, subscriber) {
-    return false;
-  }
-  /**
-   * Get active subscriptions for a subscriber
-   */
-  async getActiveSubscriptions(subscriber) {
-    return [];
-  }
-  /**
-   * Get all subscribers for a creator
-   */
-  async getSubscribers(creator) {
-    return [];
-  }
-  /**
-   * Get a specific plan by ID
-   */
-  async getPlan(planId) {
-    return null;
-  }
-  /**
-   * Get all plans for a creator
-   */
-  async getCreatorPlans(creator) {
-    return [];
-  }
-  /**
-   * Generate a unique plan ID
-   */
-  generatePlanId(name) {
-    const bytes = new Uint8Array(16);
-    crypto.getRandomValues(bytes);
-    return "0x" + Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+// src/abi/ZubariTips.json
+var ZubariTips_default = [
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "_treasury",
+        type: "address"
+      },
+      {
+        internalType: "uint256",
+        name: "_platformFeeBps",
+        type: "uint256"
+      }
+    ],
+    stateMutability: "nonpayable",
+    type: "constructor"
+  },
+  {
+    inputs: [],
+    name: "EnforcedPause",
+    type: "error"
+  },
+  {
+    inputs: [],
+    name: "ExpectedPause",
+    type: "error"
+  },
+  {
+    inputs: [],
+    name: "InvalidAddress",
+    type: "error"
+  },
+  {
+    inputs: [],
+    name: "InvalidAmount",
+    type: "error"
+  },
+  {
+    inputs: [],
+    name: "InvalidFee",
+    type: "error"
+  },
+  {
+    inputs: [],
+    name: "InvalidRecipient",
+    type: "error"
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "owner",
+        type: "address"
+      }
+    ],
+    name: "OwnableInvalidOwner",
+    type: "error"
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "account",
+        type: "address"
+      }
+    ],
+    name: "OwnableUnauthorizedAccount",
+    type: "error"
+  },
+  {
+    inputs: [],
+    name: "ReentrancyGuardReentrantCall",
+    type: "error"
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "token",
+        type: "address"
+      }
+    ],
+    name: "SafeERC20FailedOperation",
+    type: "error"
+  },
+  {
+    inputs: [],
+    name: "TransferFailed",
+    type: "error"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: false,
+        internalType: "uint256[]",
+        name: "tipIds",
+        type: "uint256[]"
+      },
+      {
+        indexed: true,
+        internalType: "address",
+        name: "sender",
+        type: "address"
+      }
+    ],
+    name: "BatchTipSent",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "address",
+        name: "previousOwner",
+        type: "address"
+      },
+      {
+        indexed: true,
+        internalType: "address",
+        name: "newOwner",
+        type: "address"
+      }
+    ],
+    name: "OwnershipTransferred",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: false,
+        internalType: "address",
+        name: "account",
+        type: "address"
+      }
+    ],
+    name: "Paused",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: false,
+        internalType: "uint256",
+        name: "oldFee",
+        type: "uint256"
+      },
+      {
+        indexed: false,
+        internalType: "uint256",
+        name: "newFee",
+        type: "uint256"
+      }
+    ],
+    name: "PlatformFeeUpdated",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "uint256",
+        name: "tipId",
+        type: "uint256"
+      },
+      {
+        indexed: true,
+        internalType: "address",
+        name: "sender",
+        type: "address"
+      },
+      {
+        indexed: true,
+        internalType: "address",
+        name: "recipient",
+        type: "address"
+      },
+      {
+        indexed: false,
+        internalType: "address",
+        name: "token",
+        type: "address"
+      },
+      {
+        indexed: false,
+        internalType: "uint256",
+        name: "amount",
+        type: "uint256"
+      },
+      {
+        indexed: false,
+        internalType: "uint256",
+        name: "platformFee",
+        type: "uint256"
+      },
+      {
+        indexed: false,
+        internalType: "string",
+        name: "message",
+        type: "string"
+      }
+    ],
+    name: "TipSent",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: false,
+        internalType: "address",
+        name: "oldTreasury",
+        type: "address"
+      },
+      {
+        indexed: false,
+        internalType: "address",
+        name: "newTreasury",
+        type: "address"
+      }
+    ],
+    name: "TreasuryUpdated",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: false,
+        internalType: "address",
+        name: "account",
+        type: "address"
+      }
+    ],
+    name: "Unpaused",
+    type: "event"
+  },
+  {
+    inputs: [
+      {
+        internalType: "uint256",
+        name: "tipId",
+        type: "uint256"
+      }
+    ],
+    name: "getTip",
+    outputs: [
+      {
+        components: [
+          {
+            internalType: "uint256",
+            name: "tipId",
+            type: "uint256"
+          },
+          {
+            internalType: "address",
+            name: "sender",
+            type: "address"
+          },
+          {
+            internalType: "address",
+            name: "recipient",
+            type: "address"
+          },
+          {
+            internalType: "address",
+            name: "token",
+            type: "address"
+          },
+          {
+            internalType: "uint256",
+            name: "amount",
+            type: "uint256"
+          },
+          {
+            internalType: "uint256",
+            name: "platformFee",
+            type: "uint256"
+          },
+          {
+            internalType: "string",
+            name: "message",
+            type: "string"
+          },
+          {
+            internalType: "uint256",
+            name: "timestamp",
+            type: "uint256"
+          }
+        ],
+        internalType: "struct ZubariTips.Tip",
+        name: "",
+        type: "tuple"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "owner",
+    outputs: [
+      {
+        internalType: "address",
+        name: "",
+        type: "address"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "pause",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "paused",
+    outputs: [
+      {
+        internalType: "bool",
+        name: "",
+        type: "bool"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "platformFeeBps",
+    outputs: [
+      {
+        internalType: "uint256",
+        name: "",
+        type: "uint256"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "renounceOwnership",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "address[]",
+        name: "recipients",
+        type: "address[]"
+      },
+      {
+        internalType: "uint256[]",
+        name: "amounts",
+        type: "uint256[]"
+      },
+      {
+        internalType: "string[]",
+        name: "messages",
+        type: "string[]"
+      }
+    ],
+    name: "sendBatchTips",
+    outputs: [],
+    stateMutability: "payable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "uint256",
+        name: "_feeBps",
+        type: "uint256"
+      }
+    ],
+    name: "setPlatformFee",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "_treasury",
+        type: "address"
+      }
+    ],
+    name: "setTreasury",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "tipCounter",
+    outputs: [
+      {
+        internalType: "uint256",
+        name: "",
+        type: "uint256"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "recipient",
+        type: "address"
+      },
+      {
+        internalType: "string",
+        name: "message",
+        type: "string"
+      }
+    ],
+    name: "tipETH",
+    outputs: [],
+    stateMutability: "payable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "recipient",
+        type: "address"
+      },
+      {
+        internalType: "address",
+        name: "token",
+        type: "address"
+      },
+      {
+        internalType: "uint256",
+        name: "amount",
+        type: "uint256"
+      },
+      {
+        internalType: "string",
+        name: "message",
+        type: "string"
+      }
+    ],
+    name: "tipToken",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "uint256",
+        name: "",
+        type: "uint256"
+      }
+    ],
+    name: "tips",
+    outputs: [
+      {
+        internalType: "uint256",
+        name: "tipId",
+        type: "uint256"
+      },
+      {
+        internalType: "address",
+        name: "sender",
+        type: "address"
+      },
+      {
+        internalType: "address",
+        name: "recipient",
+        type: "address"
+      },
+      {
+        internalType: "address",
+        name: "token",
+        type: "address"
+      },
+      {
+        internalType: "uint256",
+        name: "amount",
+        type: "uint256"
+      },
+      {
+        internalType: "uint256",
+        name: "platformFee",
+        type: "uint256"
+      },
+      {
+        internalType: "string",
+        name: "message",
+        type: "string"
+      },
+      {
+        internalType: "uint256",
+        name: "timestamp",
+        type: "uint256"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "",
+        type: "address"
+      }
+    ],
+    name: "totalTipsReceived",
+    outputs: [
+      {
+        internalType: "uint256",
+        name: "",
+        type: "uint256"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "newOwner",
+        type: "address"
+      }
+    ],
+    name: "transferOwnership",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "treasury",
+    outputs: [
+      {
+        internalType: "address",
+        name: "",
+        type: "address"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "unpause",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  }
+];
+
+// src/protocols/TipsProtocol.ts
+var ZubariTipsProtocol = class {
+  contractAddress;
+  chainId;
+  abi = ZubariTips_default;
+  constructor(contractAddress, chainId) {
+    this.contractAddress = contractAddress;
+    this.chainId = chainId;
+  }
+  /**
+   * Get the contract ABI
+   */
+  getAbi() {
+    return this.abi;
+  }
+  /**
+   * Get the contract address
+   */
+  getAddress() {
+    return this.contractAddress;
+  }
+  /**
+   * 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)
+   */
+  async tipETH(recipient, message, signer, value) {
+    if (!recipient || recipient === "0x0000000000000000000000000000000000000000") {
+      throw new Error("Invalid recipient address");
+    }
+    if (value <= 0n) {
+      throw new Error("Tip amount must be greater than 0");
+    }
+    const iface = new (await import('ethers')).Interface(this.abi);
+    const data = iface.encodeFunctionData("tipETH", [recipient, message || ""]);
+    const result = await signer.sendTransaction({
+      to: this.contractAddress,
+      value,
+      data
+    });
+    return {
+      hash: result.hash,
+      network: "ethereum",
+      status: "pending"
+    };
+  }
+  /**
+   * 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
+   */
+  async tipToken(recipient, token, amount, message, signer) {
+    if (!recipient || recipient === "0x0000000000000000000000000000000000000000") {
+      throw new Error("Invalid recipient address");
+    }
+    if (!token || token === "0x0000000000000000000000000000000000000000") {
+      throw new Error("Use tipETH for native ETH tips");
+    }
+    if (amount <= 0n) {
+      throw new Error("Tip amount must be greater than 0");
+    }
+    const iface = new (await import('ethers')).Interface(this.abi);
+    const data = iface.encodeFunctionData("tipToken", [recipient, token, amount, message || ""]);
+    const result = await signer.sendTransaction({
+      to: this.contractAddress,
+      value: 0n,
+      data
+    });
+    return {
+      hash: result.hash,
+      network: "ethereum",
+      status: "pending"
+    };
+  }
+  /**
+   * 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
+   */
+  async sendBatchTips(recipients, amounts, messages, signer, value) {
+    if (recipients.length === 0) {
+      throw new Error("At least one recipient is required");
+    }
+    if (recipients.length !== amounts.length || recipients.length !== messages.length) {
+      throw new Error("Recipients, amounts, and messages arrays must have the same length");
+    }
+    for (const recipient of recipients) {
+      if (!recipient || recipient === "0x0000000000000000000000000000000000000000") {
+        throw new Error("Invalid recipient address in batch");
+      }
+    }
+    const totalAmount = amounts.reduce((sum, amount) => sum + amount, 0n);
+    if (totalAmount <= 0n) {
+      throw new Error("Total tip amount must be greater than 0");
+    }
+    const iface = new (await import('ethers')).Interface(this.abi);
+    const data = iface.encodeFunctionData("sendBatchTips", [recipients, amounts, messages]);
+    const result = await signer.sendTransaction({
+      to: this.contractAddress,
+      value,
+      data
+    });
+    return {
+      hash: result.hash,
+      network: "ethereum",
+      status: "pending"
+    };
+  }
+  /**
+   * Get tip details by ID
+   * @param tipId The tip ID
+   * @param provider JSON-RPC provider
+   */
+  async getTip(tipId, provider) {
+    const iface = new (await import('ethers')).Interface(this.abi);
+    const data = iface.encodeFunctionData("getTip", [tipId]);
+    try {
+      const result = await provider.call({
+        to: this.contractAddress,
+        data
+      });
+      const decoded = iface.decodeFunctionResult("getTip", result);
+      const tip = decoded[0];
+      if (BigInt(tip.tipId) === 0n) {
+        return null;
+      }
+      return {
+        tipId: tip.tipId.toString(),
+        sender: tip.sender,
+        recipient: tip.recipient,
+        token: tip.token,
+        amount: BigInt(tip.amount),
+        platformFee: BigInt(tip.platformFee),
+        message: tip.message,
+        timestamp: Number(tip.timestamp)
+      };
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Get total tips received by an address
+   * @param address The address to query
+   * @param provider JSON-RPC provider
+   */
+  async getTotalTipsReceived(address, provider) {
+    const iface = new (await import('ethers')).Interface(this.abi);
+    const data = iface.encodeFunctionData("totalTipsReceived", [address]);
+    try {
+      const result = await provider.call({
+        to: this.contractAddress,
+        data
+      });
+      const decoded = iface.decodeFunctionResult("totalTipsReceived", result);
+      return BigInt(decoded[0]);
+    } catch {
+      return 0n;
+    }
+  }
+  /**
+   * Get platform fee in basis points
+   * @param provider JSON-RPC provider
+   */
+  async getPlatformFeeBps(provider) {
+    const iface = new (await import('ethers')).Interface(this.abi);
+    const data = iface.encodeFunctionData("platformFeeBps", []);
+    try {
+      const result = await provider.call({
+        to: this.contractAddress,
+        data
+      });
+      const decoded = iface.decodeFunctionResult("platformFeeBps", result);
+      return Number(decoded[0]);
+    } catch {
+      return 300;
+    }
+  }
+  /**
+   * Get current tip counter
+   * @param provider JSON-RPC provider
+   */
+  async getTipCounter(provider) {
+    const iface = new (await import('ethers')).Interface(this.abi);
+    const data = iface.encodeFunctionData("tipCounter", []);
+    try {
+      const result = await provider.call({
+        to: this.contractAddress,
+        data
+      });
+      const decoded = iface.decodeFunctionResult("tipCounter", result);
+      return BigInt(decoded[0]);
+    } catch {
+      return 0n;
+    }
+  }
+  /**
+   * Get treasury address
+   * @param provider JSON-RPC provider
+   */
+  async getTreasury(provider) {
+    const iface = new (await import('ethers')).Interface(this.abi);
+    const data = iface.encodeFunctionData("treasury", []);
+    try {
+      const result = await provider.call({
+        to: this.contractAddress,
+        data
+      });
+      const decoded = iface.decodeFunctionResult("treasury", result);
+      return decoded[0];
+    } catch {
+      return "0x0000000000000000000000000000000000000000";
+    }
+  }
+  /**
+   * Calculate platform fee for a given amount
+   * @param amount The tip amount
+   * @param feeBps Fee in basis points (default: 300 = 3%)
+   */
+  calculateFee(amount, feeBps = 300) {
+    const fee = amount * BigInt(feeBps) / 10000n;
+    return {
+      fee,
+      creatorAmount: amount - fee
+    };
+  }
+};
+
+// src/abi/ZubariSubscription.json
+var ZubariSubscription_default = [
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "_treasury",
+        type: "address"
+      },
+      {
+        internalType: "uint256",
+        name: "_platformFeeBps",
+        type: "uint256"
+      }
+    ],
+    stateMutability: "nonpayable",
+    type: "constructor"
+  },
+  {
+    inputs: [],
+    name: "AlreadySubscribed",
+    type: "error"
+  },
+  {
+    inputs: [],
+    name: "EnforcedPause",
+    type: "error"
+  },
+  {
+    inputs: [],
+    name: "ExpectedPause",
+    type: "error"
+  },
+  {
+    inputs: [],
+    name: "InvalidAddress",
+    type: "error"
+  },
+  {
+    inputs: [],
+    name: "InvalidAmount",
+    type: "error"
+  },
+  {
+    inputs: [],
+    name: "InvalidDuration",
+    type: "error"
+  },
+  {
+    inputs: [],
+    name: "InvalidFee",
+    type: "error"
+  },
+  {
+    inputs: [],
+    name: "NotSubscriber",
+    type: "error"
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "owner",
+        type: "address"
+      }
+    ],
+    name: "OwnableInvalidOwner",
+    type: "error"
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "account",
+        type: "address"
+      }
+    ],
+    name: "OwnableUnauthorizedAccount",
+    type: "error"
+  },
+  {
+    inputs: [],
+    name: "PlanFull",
+    type: "error"
+  },
+  {
+    inputs: [],
+    name: "PlanNotActive",
+    type: "error"
+  },
+  {
+    inputs: [],
+    name: "PlanNotFound",
+    type: "error"
+  },
+  {
+    inputs: [],
+    name: "ReentrancyGuardReentrantCall",
+    type: "error"
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "token",
+        type: "address"
+      }
+    ],
+    name: "SafeERC20FailedOperation",
+    type: "error"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "address",
+        name: "previousOwner",
+        type: "address"
+      },
+      {
+        indexed: true,
+        internalType: "address",
+        name: "newOwner",
+        type: "address"
+      }
+    ],
+    name: "OwnershipTransferred",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: false,
+        internalType: "address",
+        name: "account",
+        type: "address"
+      }
+    ],
+    name: "Paused",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "bytes32",
+        name: "planId",
+        type: "bytes32"
+      },
+      {
+        indexed: true,
+        internalType: "address",
+        name: "creator",
+        type: "address"
+      },
+      {
+        indexed: false,
+        internalType: "string",
+        name: "name",
+        type: "string"
+      },
+      {
+        indexed: false,
+        internalType: "uint256",
+        name: "price",
+        type: "uint256"
+      }
+    ],
+    name: "PlanCreated",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "bytes32",
+        name: "planId",
+        type: "bytes32"
+      }
+    ],
+    name: "PlanDeactivated",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "bytes32",
+        name: "planId",
+        type: "bytes32"
+      }
+    ],
+    name: "PlanUpdated",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "bytes32",
+        name: "subscriptionId",
+        type: "bytes32"
+      },
+      {
+        indexed: true,
+        internalType: "bytes32",
+        name: "planId",
+        type: "bytes32"
+      },
+      {
+        indexed: true,
+        internalType: "address",
+        name: "subscriber",
+        type: "address"
+      },
+      {
+        indexed: false,
+        internalType: "address",
+        name: "creator",
+        type: "address"
+      },
+      {
+        indexed: false,
+        internalType: "uint256",
+        name: "endTime",
+        type: "uint256"
+      }
+    ],
+    name: "Subscribed",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "bytes32",
+        name: "subscriptionId",
+        type: "bytes32"
+      }
+    ],
+    name: "SubscriptionCancelled",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "bytes32",
+        name: "subscriptionId",
+        type: "bytes32"
+      },
+      {
+        indexed: false,
+        internalType: "uint256",
+        name: "newEndTime",
+        type: "uint256"
+      }
+    ],
+    name: "SubscriptionRenewed",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: false,
+        internalType: "address",
+        name: "account",
+        type: "address"
+      }
+    ],
+    name: "Unpaused",
+    type: "event"
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "",
+        type: "address"
+      },
+      {
+        internalType: "address",
+        name: "",
+        type: "address"
+      }
+    ],
+    name: "activeSubscription",
+    outputs: [
+      {
+        internalType: "bytes32",
+        name: "",
+        type: "bytes32"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes32",
+        name: "subscriptionId",
+        type: "bytes32"
+      }
+    ],
+    name: "cancel",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "string",
+        name: "name",
+        type: "string"
+      },
+      {
+        internalType: "string",
+        name: "description",
+        type: "string"
+      },
+      {
+        internalType: "uint256",
+        name: "price",
+        type: "uint256"
+      },
+      {
+        internalType: "address",
+        name: "paymentToken",
+        type: "address"
+      },
+      {
+        internalType: "uint256",
+        name: "durationDays",
+        type: "uint256"
+      },
+      {
+        internalType: "uint256",
+        name: "maxSubscribers",
+        type: "uint256"
+      }
+    ],
+    name: "createPlan",
+    outputs: [
+      {
+        internalType: "bytes32",
+        name: "",
+        type: "bytes32"
+      }
+    ],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "",
+        type: "address"
+      },
+      {
+        internalType: "uint256",
+        name: "",
+        type: "uint256"
+      }
+    ],
+    name: "creatorPlans",
+    outputs: [
+      {
+        internalType: "bytes32",
+        name: "",
+        type: "bytes32"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes32",
+        name: "planId",
+        type: "bytes32"
+      }
+    ],
+    name: "deactivatePlan",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "creator",
+        type: "address"
+      }
+    ],
+    name: "getCreatorPlans",
+    outputs: [
+      {
+        internalType: "bytes32[]",
+        name: "",
+        type: "bytes32[]"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes32",
+        name: "planId",
+        type: "bytes32"
+      }
+    ],
+    name: "getPlan",
+    outputs: [
+      {
+        components: [
+          {
+            internalType: "bytes32",
+            name: "planId",
+            type: "bytes32"
+          },
+          {
+            internalType: "address",
+            name: "creator",
+            type: "address"
+          },
+          {
+            internalType: "string",
+            name: "name",
+            type: "string"
+          },
+          {
+            internalType: "string",
+            name: "description",
+            type: "string"
+          },
+          {
+            internalType: "uint256",
+            name: "price",
+            type: "uint256"
+          },
+          {
+            internalType: "address",
+            name: "paymentToken",
+            type: "address"
+          },
+          {
+            internalType: "uint256",
+            name: "durationDays",
+            type: "uint256"
+          },
+          {
+            internalType: "uint256",
+            name: "maxSubscribers",
+            type: "uint256"
+          },
+          {
+            internalType: "uint256",
+            name: "subscriberCount",
+            type: "uint256"
+          },
+          {
+            internalType: "bool",
+            name: "isActive",
+            type: "bool"
+          }
+        ],
+        internalType: "struct ZubariSubscription.SubscriptionPlan",
+        name: "",
+        type: "tuple"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes32",
+        name: "subscriptionId",
+        type: "bytes32"
+      }
+    ],
+    name: "getSubscription",
+    outputs: [
+      {
+        components: [
+          {
+            internalType: "bytes32",
+            name: "subscriptionId",
+            type: "bytes32"
+          },
+          {
+            internalType: "bytes32",
+            name: "planId",
+            type: "bytes32"
+          },
+          {
+            internalType: "address",
+            name: "creator",
+            type: "address"
+          },
+          {
+            internalType: "address",
+            name: "subscriber",
+            type: "address"
+          },
+          {
+            internalType: "uint256",
+            name: "startTime",
+            type: "uint256"
+          },
+          {
+            internalType: "uint256",
+            name: "endTime",
+            type: "uint256"
+          },
+          {
+            internalType: "bool",
+            name: "autoRenew",
+            type: "bool"
+          },
+          {
+            internalType: "enum ZubariSubscription.SubscriptionStatus",
+            name: "status",
+            type: "uint8"
+          }
+        ],
+        internalType: "struct ZubariSubscription.Subscription",
+        name: "",
+        type: "tuple"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "subscriber",
+        type: "address"
+      },
+      {
+        internalType: "address",
+        name: "creator",
+        type: "address"
+      }
+    ],
+    name: "isSubscribed",
+    outputs: [
+      {
+        internalType: "bool",
+        name: "",
+        type: "bool"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "owner",
+    outputs: [
+      {
+        internalType: "address",
+        name: "",
+        type: "address"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "pause",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "paused",
+    outputs: [
+      {
+        internalType: "bool",
+        name: "",
+        type: "bool"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes32",
+        name: "",
+        type: "bytes32"
+      }
+    ],
+    name: "plans",
+    outputs: [
+      {
+        internalType: "bytes32",
+        name: "planId",
+        type: "bytes32"
+      },
+      {
+        internalType: "address",
+        name: "creator",
+        type: "address"
+      },
+      {
+        internalType: "string",
+        name: "name",
+        type: "string"
+      },
+      {
+        internalType: "string",
+        name: "description",
+        type: "string"
+      },
+      {
+        internalType: "uint256",
+        name: "price",
+        type: "uint256"
+      },
+      {
+        internalType: "address",
+        name: "paymentToken",
+        type: "address"
+      },
+      {
+        internalType: "uint256",
+        name: "durationDays",
+        type: "uint256"
+      },
+      {
+        internalType: "uint256",
+        name: "maxSubscribers",
+        type: "uint256"
+      },
+      {
+        internalType: "uint256",
+        name: "subscriberCount",
+        type: "uint256"
+      },
+      {
+        internalType: "bool",
+        name: "isActive",
+        type: "bool"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "platformFeeBps",
+    outputs: [
+      {
+        internalType: "uint256",
+        name: "",
+        type: "uint256"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "renounceOwnership",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes32",
+        name: "subscriptionId",
+        type: "bytes32"
+      },
+      {
+        internalType: "bool",
+        name: "autoRenew",
+        type: "bool"
+      }
+    ],
+    name: "setAutoRenew",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "uint256",
+        name: "_feeBps",
+        type: "uint256"
+      }
+    ],
+    name: "setPlatformFee",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "_treasury",
+        type: "address"
+      }
+    ],
+    name: "setTreasury",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes32",
+        name: "planId",
+        type: "bytes32"
+      },
+      {
+        internalType: "uint256",
+        name: "months",
+        type: "uint256"
+      }
+    ],
+    name: "subscribe",
+    outputs: [
+      {
+        internalType: "bytes32",
+        name: "",
+        type: "bytes32"
+      }
+    ],
+    stateMutability: "payable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "",
+        type: "address"
+      },
+      {
+        internalType: "uint256",
+        name: "",
+        type: "uint256"
+      }
+    ],
+    name: "subscriberSubscriptions",
+    outputs: [
+      {
+        internalType: "bytes32",
+        name: "",
+        type: "bytes32"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes32",
+        name: "",
+        type: "bytes32"
+      }
+    ],
+    name: "subscriptions",
+    outputs: [
+      {
+        internalType: "bytes32",
+        name: "subscriptionId",
+        type: "bytes32"
+      },
+      {
+        internalType: "bytes32",
+        name: "planId",
+        type: "bytes32"
+      },
+      {
+        internalType: "address",
+        name: "creator",
+        type: "address"
+      },
+      {
+        internalType: "address",
+        name: "subscriber",
+        type: "address"
+      },
+      {
+        internalType: "uint256",
+        name: "startTime",
+        type: "uint256"
+      },
+      {
+        internalType: "uint256",
+        name: "endTime",
+        type: "uint256"
+      },
+      {
+        internalType: "bool",
+        name: "autoRenew",
+        type: "bool"
+      },
+      {
+        internalType: "enum ZubariSubscription.SubscriptionStatus",
+        name: "status",
+        type: "uint8"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "newOwner",
+        type: "address"
+      }
+    ],
+    name: "transferOwnership",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "treasury",
+    outputs: [
+      {
+        internalType: "address",
+        name: "",
+        type: "address"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "unpause",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  }
+];
+
+// src/protocols/SubscriptionProtocol.ts
+var ZubariSubscriptionProtocol = class {
+  contractAddress;
+  chainId;
+  abi = ZubariSubscription_default;
+  constructor(contractAddress, chainId) {
+    this.contractAddress = contractAddress;
+    this.chainId = chainId;
+  }
+  /**
+   * Get the contract ABI
+   */
+  getAbi() {
+    return this.abi;
+  }
+  /**
+   * Get the contract address
+   */
+  getAddress() {
+    return this.contractAddress;
+  }
+  /**
+   * Create a new subscription plan
+   * @param plan The plan details
+   * @param signer Wallet signer with sendTransaction method
+   */
+  async createPlan(plan, signer) {
+    if (!plan.name || plan.name.length === 0) {
+      throw new Error("Plan name is required");
+    }
+    if (plan.price <= 0n) {
+      throw new Error("Plan price must be greater than 0");
+    }
+    if (plan.duration <= 0) {
+      throw new Error("Plan duration must be greater than 0");
+    }
+    const iface = new (await import('ethers')).Interface(this.abi);
+    const durationDays = Math.ceil(plan.duration / (24 * 60 * 60));
+    const data = iface.encodeFunctionData("createPlan", [
+      plan.name,
+      plan.description || "",
+      plan.price,
+      plan.paymentToken || "0x0000000000000000000000000000000000000000",
+      // ETH by default
+      durationDays,
+      plan.maxSubscribers || 0
+      // 0 = unlimited
+    ]);
+    const result = await signer.sendTransaction({
+      to: this.contractAddress,
+      value: 0n,
+      data
+    });
+    return result.hash;
+  }
+  /**
+   * Deactivate a subscription plan (only creator can do this)
+   * @param planId The plan ID to deactivate
+   * @param signer Wallet signer
+   */
+  async deactivatePlan(planId, signer) {
+    const iface = new (await import('ethers')).Interface(this.abi);
+    const data = iface.encodeFunctionData("deactivatePlan", [planId]);
+    const result = await signer.sendTransaction({
+      to: this.contractAddress,
+      value: 0n,
+      data
+    });
+    return {
+      hash: result.hash,
+      network: "ethereum",
+      status: "pending"
+    };
+  }
+  /**
+   * 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)
+   */
+  async subscribe(planId, months, signer, value) {
+    if (months <= 0) {
+      throw new Error("Subscription duration must be at least 1 month");
+    }
+    const iface = new (await import('ethers')).Interface(this.abi);
+    const data = iface.encodeFunctionData("subscribe", [planId, months]);
+    const result = await signer.sendTransaction({
+      to: this.contractAddress,
+      value: value || 0n,
+      data
+    });
+    return {
+      hash: result.hash,
+      network: "ethereum",
+      status: "pending"
+    };
+  }
+  /**
+   * Cancel an active subscription
+   * @param subscriptionId The subscription ID to cancel
+   * @param signer Wallet signer
+   */
+  async cancel(subscriptionId, signer) {
+    const iface = new (await import('ethers')).Interface(this.abi);
+    const data = iface.encodeFunctionData("cancel", [subscriptionId]);
+    const result = await signer.sendTransaction({
+      to: this.contractAddress,
+      value: 0n,
+      data
+    });
+    return {
+      hash: result.hash,
+      network: "ethereum",
+      status: "pending"
+    };
+  }
+  /**
+   * Set auto-renew for a subscription
+   * @param subscriptionId The subscription ID
+   * @param autoRenew Whether to enable auto-renew
+   * @param signer Wallet signer
+   */
+  async setAutoRenew(subscriptionId, autoRenew, signer) {
+    const iface = new (await import('ethers')).Interface(this.abi);
+    const data = iface.encodeFunctionData("setAutoRenew", [subscriptionId, autoRenew]);
+    const result = await signer.sendTransaction({
+      to: this.contractAddress,
+      value: 0n,
+      data
+    });
+    return {
+      hash: result.hash,
+      network: "ethereum",
+      status: "pending"
+    };
+  }
+  /**
+   * Check if an address is subscribed to a creator
+   * @param subscriber The subscriber address
+   * @param creator The creator address
+   * @param provider JSON-RPC provider
+   */
+  async isSubscribed(subscriber, creator, provider) {
+    const iface = new (await import('ethers')).Interface(this.abi);
+    const data = iface.encodeFunctionData("isSubscribed", [subscriber, creator]);
+    try {
+      const result = await provider.call({
+        to: this.contractAddress,
+        data
+      });
+      const decoded = iface.decodeFunctionResult("isSubscribed", result);
+      return decoded[0];
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Get the active subscription ID between subscriber and creator
+   * @param subscriber The subscriber address
+   * @param creator The creator address
+   * @param provider JSON-RPC provider
+   */
+  async getActiveSubscriptionId(subscriber, creator, provider) {
+    const iface = new (await import('ethers')).Interface(this.abi);
+    const data = iface.encodeFunctionData("activeSubscription", [subscriber, creator]);
+    try {
+      const result = await provider.call({
+        to: this.contractAddress,
+        data
+      });
+      const decoded = iface.decodeFunctionResult("activeSubscription", result);
+      const subscriptionId = decoded[0];
+      if (subscriptionId === "0x0000000000000000000000000000000000000000000000000000000000000000") {
+        return null;
+      }
+      return subscriptionId;
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Get subscription details by ID
+   * @param subscriptionId The subscription ID
+   * @param provider JSON-RPC provider
+   */
+  async getSubscription(subscriptionId, provider) {
+    const iface = new (await import('ethers')).Interface(this.abi);
+    const data = iface.encodeFunctionData("getSubscription", [subscriptionId]);
+    try {
+      const result = await provider.call({
+        to: this.contractAddress,
+        data
+      });
+      const decoded = iface.decodeFunctionResult("getSubscription", result);
+      const sub = decoded[0];
+      if (sub.subscriptionId === "0x0000000000000000000000000000000000000000000000000000000000000000") {
+        return null;
+      }
+      let status;
+      switch (Number(sub.status)) {
+        case 0 /* Active */:
+          status = "active";
+          break;
+        case 1 /* Cancelled */:
+          status = "cancelled";
+          break;
+        case 2 /* Expired */:
+          status = "expired";
+          break;
+        default:
+          status = "active";
+      }
+      return {
+        subscriptionId: sub.subscriptionId,
+        planId: sub.planId,
+        creator: sub.creator,
+        subscriber: sub.subscriber,
+        startTime: Number(sub.startTime),
+        endTime: Number(sub.endTime),
+        autoRenew: sub.autoRenew,
+        status
+      };
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Get a specific plan by ID
+   * @param planId The plan ID
+   * @param provider JSON-RPC provider
+   */
+  async getPlan(planId, provider) {
+    const iface = new (await import('ethers')).Interface(this.abi);
+    const data = iface.encodeFunctionData("getPlan", [planId]);
+    try {
+      const result = await provider.call({
+        to: this.contractAddress,
+        data
+      });
+      const decoded = iface.decodeFunctionResult("getPlan", result);
+      const plan = decoded[0];
+      if (plan.planId === "0x0000000000000000000000000000000000000000000000000000000000000000") {
+        return null;
+      }
+      const durationSeconds = Number(plan.durationDays) * 24 * 60 * 60;
+      return {
+        planId: plan.planId,
+        name: plan.name,
+        description: plan.description,
+        price: plan.price,
+        paymentToken: plan.paymentToken,
+        duration: durationSeconds,
+        perks: [],
+        // Not stored on-chain
+        maxSubscribers: Number(plan.maxSubscribers),
+        nftBadge: false
+        // Not stored on-chain in this contract version
+      };
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Get all plan IDs for a creator
+   * @param creator The creator address
+   * @param provider JSON-RPC provider
+   */
+  async getCreatorPlanIds(creator, provider) {
+    const iface = new (await import('ethers')).Interface(this.abi);
+    const data = iface.encodeFunctionData("getCreatorPlans", [creator]);
+    try {
+      const result = await provider.call({
+        to: this.contractAddress,
+        data
+      });
+      const decoded = iface.decodeFunctionResult("getCreatorPlans", result);
+      return decoded[0];
+    } catch {
+      return [];
+    }
+  }
+  /**
+   * Get all plans for a creator with full details
+   * @param creator The creator address
+   * @param provider JSON-RPC provider
+   */
+  async getCreatorPlans(creator, provider) {
+    const planIds = await this.getCreatorPlanIds(creator, provider);
+    const plans = [];
+    for (const planId of planIds) {
+      const plan = await this.getPlan(planId, provider);
+      if (plan && plan.planId) {
+        plans.push(plan);
+      }
+    }
+    return plans;
+  }
+  /**
+   * Get platform fee in basis points
+   * @param provider JSON-RPC provider
+   */
+  async getPlatformFeeBps(provider) {
+    const iface = new (await import('ethers')).Interface(this.abi);
+    const data = iface.encodeFunctionData("platformFeeBps", []);
+    try {
+      const result = await provider.call({
+        to: this.contractAddress,
+        data
+      });
+      const decoded = iface.decodeFunctionResult("platformFeeBps", result);
+      return Number(decoded[0]);
+    } catch {
+      return 300;
+    }
+  }
+  /**
+   * Calculate the total cost for a subscription
+   * @param planPrice The plan price per period
+   * @param months Number of months
+   */
+  calculateSubscriptionCost(planPrice, months) {
+    return planPrice * BigInt(months);
+  }
+  /**
+   * Calculate platform fee for a given amount
+   * @param amount The amount
+   * @param feeBps Fee in basis points
+   */
+  calculateFee(amount, feeBps = 300) {
+    const fee = amount * BigInt(feeBps) / 10000n;
+    return {
+      fee,
+      creatorAmount: amount - fee
+    };
   }
 };
 
@@ -4378,10 +6317,13 @@ function normalizeAddress(address) {
 }
 
 exports.BrowserAddressDerivation = BrowserAddressDerivation_exports;
+exports.CURRENCY_ADDRESSES = CURRENCY_ADDRESSES;
 exports.DERIVATION_PATHS = DERIVATION_PATHS;
 exports.KeyManager = KeyManager;
 exports.MemoryStorageAdapter = MemoryStorageAdapter;
 exports.NETWORKS = NETWORKS;
+exports.NFT_VOUCHER_DOMAIN = NFT_VOUCHER_DOMAIN;
+exports.NFT_VOUCHER_TYPES = NFT_VOUCHER_TYPES;
 exports.PLATFORM_CONFIG = PLATFORM_CONFIG;
 exports.SwapService = SwapService;
 exports.TESTNET_NETWORKS = TESTNET_NETWORKS;
@@ -4389,6 +6331,7 @@ exports.TransactionService = TransactionService;
 exports.WalletManager = WalletManager;
 exports.WdkApiClient = WdkApiClient;
 exports.WebEncryptedStorageAdapter = WebEncryptedStorageAdapter;
+exports.ZERO_ADDRESS = ZERO_ADDRESS;
 exports.ZUBARI_CONTRACTS = ZUBARI_CONTRACTS;
 exports.ZubariError = ZubariError;
 exports.ZubariMarketProtocol = ZubariMarketProtocol;