@zubari/sdk 0.1.31 → 0.2.0

package/dist/protocols/index.mjs

@@ -1,4 +1,5 @@
 // src/config/contracts.ts
+var ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
 var PLATFORM_CONFIG = {
   // Platform fee in basis points (300 = 3%)
   tipFeeBps: 300,
@@ -16,37 +17,116 @@ 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
+  }
+};
 
 // src/protocols/NFTProtocol.ts
 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,
@@ -55,10 +135,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
    */