pepay-streams-sdk 0.1.0

package/src/marketplace/index.ts

@@ -0,0 +1,730 @@
+/**
+ * Marketplace Module
+ *
+ * Provides methods for P2P vesting marketplace:
+ * - Create orders (INSTANT, VESTED, TRADABLE)
+ * - Fill orders
+ * - Cancel orders
+ * - Order queries
+ */
+import {
+  type PublicClient,
+  type WalletClient,
+  type Address,
+  type Hash,
+  type Hex,
+  zeroAddress,
+} from 'viem';
+import { DIAMOND_ABI } from '@pepay-streams/abi/diamond';
+import type {
+  CreateInstantOrderParams,
+  CreateVestedOrderParams,
+  CreateTradableOrderParams,
+  OrderInfo,
+  OrderQuote,
+  TransactionResult,
+  OrderType,
+} from '../types';
+
+/**
+ * Visibility enum matching contract
+ */
+enum Visibility {
+  PUBLIC = 0,
+  PRIVATE = 1,
+}
+
+/**
+ * StartMode enum matching contract
+ */
+enum StartMode {
+  UPON_FILL = 0,
+  FIXED_TIMESTAMP = 1,
+}
+
+/**
+ * Marketplace module for P2P trading of token positions
+ */
+export class MarketplaceModule {
+  constructor(
+    private readonly publicClient: PublicClient,
+    private readonly walletClient: WalletClient | undefined,
+    private readonly diamondAddress: Address
+  ) {}
+
+  // ============================================================================
+  // Order Creation
+  // ============================================================================
+
+  /**
+   * Create an INSTANT order
+   *
+   * Seller deposits tokens upfront, buyer pays and receives immediately.
+   *
+   * @example
+   * ```typescript
+   * // Approve first
+   * await sdk.approve(sellToken, amount);
+   *
+   * const result = await sdk.marketplace.createInstantOrder({
+   *   sellToken: '0x...',
+   *   sellAmount: parseEther('1000'),
+   *   payToken: zeroAddress, // Native ETH
+   *   pricePerToken: parseEther('0.001'), // 0.001 ETH per token
+   *   expiryTTL: 7 * 24 * 60 * 60, // 7 days
+   * });
+   * ```
+   */
+  async createInstantOrder(
+    params: CreateInstantOrderParams
+  ): Promise<TransactionResult> {
+    const wallet = this.requireWallet();
+
+    const visibility =
+      params.privateBuyers && params.privateBuyers.length > 0
+        ? Visibility.PRIVATE
+        : Visibility.PUBLIC;
+
+    const expiry = BigInt(
+      Math.floor(Date.now() / 1000) + (params.expiryTTL ?? 7 * 24 * 60 * 60)
+    );
+
+    const args = {
+      payToken: params.payToken,
+      price: params.pricePerToken,
+      sellToken: params.sellToken,
+      sellAmount: params.sellAmount,
+      visibility,
+      allowedBuyers: params.privateBuyers ?? [],
+      expiry,
+    };
+
+    const hash = await wallet.writeContract({
+      chain: wallet.chain,
+      account: wallet.account!,
+      address: this.diamondAddress,
+      abi: DIAMOND_ABI,
+      functionName: 'createOrderInstant',
+      args: [args],
+    });
+
+    return this.createTransactionResult(hash);
+  }
+
+  /**
+   * Create a VESTED order
+   *
+   * Seller deposits tokens that vest over time for the buyer.
+   *
+   * @example
+   * ```typescript
+   * const result = await sdk.marketplace.createVestedOrder({
+   *   sellToken: '0x...',
+   *   sellAmount: parseEther('10000'),
+   *   payToken: '0x...', // USDC
+   *   pricePerToken: 1000000n, // 1 USDC (6 decimals)
+   *   vestingDuration: 365 * 24 * 60 * 60, // 1 year
+   *   cliffDuration: 30 * 24 * 60 * 60, // 30 day cliff
+   *   startMode: 'upon_fill', // Vesting starts when order is filled
+   * });
+   * ```
+   */
+  async createVestedOrder(
+    params: CreateVestedOrderParams
+  ): Promise<TransactionResult> {
+    const wallet = this.requireWallet();
+
+    const visibility =
+      params.privateBuyers && params.privateBuyers.length > 0
+        ? Visibility.PRIVATE
+        : Visibility.PUBLIC;
+
+    const expiry = BigInt(
+      Math.floor(Date.now() / 1000) + (params.expiryTTL ?? 7 * 24 * 60 * 60)
+    );
+
+    // Convert cliff duration to basis points (percentage of total duration)
+    const cliffBps =
+      params.cliffDuration && params.vestingDuration
+        ? Math.floor((params.cliffDuration / params.vestingDuration) * 10000)
+        : 0;
+
+    const args = {
+      payToken: params.payToken,
+      price: params.pricePerToken,
+      sellToken: params.sellToken,
+      sellAmount: params.sellAmount,
+      visibility,
+      allowedBuyers: params.privateBuyers ?? [],
+      expiry,
+      vest: {
+        startMode:
+          params.startMode === 'fixed_timestamp'
+            ? StartMode.FIXED_TIMESTAMP
+            : StartMode.UPON_FILL,
+        startAt: BigInt(params.fixedStartTime ?? 0),
+        durationSec: params.vestingDuration,
+        stepSec: 0, // Linear vesting
+        cliffBps,
+      },
+    };
+
+    const hash = await wallet.writeContract({
+      chain: wallet.chain,
+      account: wallet.account!,
+      address: this.diamondAddress,
+      abi: DIAMOND_ABI,
+      functionName: 'createOrderVested',
+      args: [args],
+    });
+
+    return this.createTransactionResult(hash);
+  }
+
+  /**
+   * Create a TRADABLE order
+   *
+   * List an unvested campaign position for sale. No upfront deposit -
+   * the position is transferred when the order is filled.
+   *
+   * @example
+   * ```typescript
+   * // Must have a position in a VestedAirdrop campaign with trading enabled
+   * const result = await sdk.marketplace.createTradableOrder({
+   *   campaignId: 10n,
+   *   pricePerToken: parseEther('0.05'), // 0.05 ETH per token
+   *   payToken: zeroAddress, // Native ETH
+   *   expiryTTL: 30 * 24 * 60 * 60, // 30 days
+   * });
+   * console.log('Order created, tx:', result.hash);
+   * ```
+   */
+  async createTradableOrder(
+    params: CreateTradableOrderParams
+  ): Promise<TransactionResult> {
+    const wallet = this.requireWallet();
+
+    const visibility =
+      params.privateBuyers && params.privateBuyers.length > 0
+        ? Visibility.PRIVATE
+        : Visibility.PUBLIC;
+
+    const expiry = BigInt(
+      Math.floor(Date.now() / 1000) + (params.expiryTTL ?? 30 * 24 * 60 * 60)
+    );
+
+    const args = {
+      payToken: params.payToken,
+      price: params.pricePerToken,
+      campaignId: params.campaignId,
+      visibility,
+      allowedBuyers: params.privateBuyers ?? [],
+      expiry,
+      escrowRouting: zeroAddress, // Default to no escrow routing
+    };
+
+    const hash = await wallet.writeContract({
+      chain: wallet.chain,
+      account: wallet.account!,
+      address: this.diamondAddress,
+      abi: DIAMOND_ABI,
+      functionName: 'createOrderTradable',
+      args: [args],
+    });
+
+    return this.createTransactionResult(hash);
+  }
+
+  // ============================================================================
+  // Order Settlement
+  // ============================================================================
+
+  /**
+   * Fill an order (buy)
+   *
+   * For native payment orders, send ETH as value.
+   * For token payment orders, approve the Diamond first.
+   *
+   * @example
+   * ```typescript
+   * // Get quote first
+   * const quote = await sdk.marketplace.getQuote(orderId);
+   *
+   * // Fill with native ETH
+   * const result = await sdk.marketplace.fillOrder(orderId, {
+   *   value: quote.totalPrice,
+   * });
+   *
+   * // Or fill with ERC20 (approve first)
+   * await sdk.approve(payToken, quote.totalPrice);
+   * await sdk.marketplace.fillOrder(orderId);
+   * ```
+   */
+  async fillOrder(
+    orderId: bigint,
+    options?: { value?: bigint }
+  ): Promise<TransactionResult> {
+    const wallet = this.requireWallet();
+
+    const hash = await wallet.writeContract({
+      chain: wallet.chain,
+      account: wallet.account!,
+      address: this.diamondAddress,
+      abi: DIAMOND_ABI,
+      functionName: 'fillOrder',
+      args: [orderId],
+      value: options?.value,
+    });
+
+    return this.createTransactionResult(hash);
+  }
+
+  /**
+   * Fill an order using Permit2 (gasless token approval)
+   */
+  async fillOrderWithPermit(params: {
+    orderId: bigint;
+    permit2Payload: Hex;
+  }): Promise<TransactionResult> {
+    const wallet = this.requireWallet();
+
+    const hash = await wallet.writeContract({
+      chain: wallet.chain,
+      account: wallet.account!,
+      address: this.diamondAddress,
+      abi: DIAMOND_ABI,
+      functionName: 'fillOrderWithPermit',
+      args: [params.orderId, params.permit2Payload],
+    });
+
+    return this.createTransactionResult(hash);
+  }
+
+  /**
+   * Cancel an order (seller only)
+   *
+   * Returns deposited tokens to seller.
+   *
+   * @example
+   * ```typescript
+   * const result = await sdk.marketplace.cancelOrder(orderId);
+   * ```
+   */
+  async cancelOrder(orderId: bigint): Promise<TransactionResult> {
+    const wallet = this.requireWallet();
+
+    const hash = await wallet.writeContract({
+      chain: wallet.chain,
+      account: wallet.account!,
+      address: this.diamondAddress,
+      abi: DIAMOND_ABI,
+      functionName: 'cancelOrder',
+      args: [orderId],
+    });
+
+    return this.createTransactionResult(hash);
+  }
+
+  /**
+   * Expire an order (anyone can call after expiry)
+   *
+   * Returns deposited tokens to seller.
+   */
+  async expireOrder(orderId: bigint): Promise<TransactionResult> {
+    const wallet = this.requireWallet();
+
+    const hash = await wallet.writeContract({
+      chain: wallet.chain,
+      account: wallet.account!,
+      address: this.diamondAddress,
+      abi: DIAMOND_ABI,
+      functionName: 'expireOrder',
+      args: [orderId],
+    });
+
+    return this.createTransactionResult(hash);
+  }
+
+  // ============================================================================
+  // Order Queries
+  // ============================================================================
+
+  /**
+   * Get order information by ID
+   *
+   * @example
+   * ```typescript
+   * const order = await sdk.marketplace.getOrder(1n);
+   * console.log('Seller:', order.seller);
+   * console.log('Price:', formatEther(order.totalPrice));
+   * console.log('Status:', order.status);
+   * ```
+   */
+  async getOrder(orderId: bigint): Promise<OrderInfo> {
+    const result = await this.publicClient.readContract({
+      address: this.diamondAddress,
+      abi: DIAMOND_ABI,
+      functionName: 'getOrder',
+      args: [orderId],
+    });
+
+    return this.parseOrderInfo(result as unknown as OrderStruct);
+  }
+
+  /**
+   * Get order quote (price breakdown)
+   *
+   * @example
+   * ```typescript
+   * const quote = await sdk.marketplace.getQuote(orderId);
+   * console.log('Total price:', formatEther(quote.totalPrice));
+   * console.log('Protocol fee:', formatEther(quote.protocolFee));
+   * ```
+   */
+  async getQuote(orderId: bigint): Promise<OrderQuote> {
+    const result = await this.publicClient.readContract({
+      address: this.diamondAddress,
+      abi: DIAMOND_ABI,
+      functionName: 'quote',
+      args: [orderId],
+    }) as { payToken: Address; feeBps: number; price: bigint; feeAmount: bigint; proceeds: bigint };
+
+    // Also get the order to know if it's still valid
+    const order = await this.getOrder(orderId);
+
+    return {
+      orderId,
+      totalPrice: result.price,
+      protocolFee: result.feeAmount,
+      buyerReceives: order.sellAmount,
+      sellerReceives: result.proceeds,
+      isValid: order.status === 'open' && order.expiresAt > Math.floor(Date.now() / 1000),
+      expiresAt: order.expiresAt,
+    };
+  }
+
+  /**
+   * Get detailed quote for filling an order
+   */
+  async getQuoteFill(orderId: bigint): Promise<{
+    payToken: Address;
+    price: bigint;
+    feeBps: number;
+    feeAmount: bigint;
+    feeReceiver: Address;
+    proceeds: bigint;
+    seller: Address;
+    sellToken: Address;
+    sellAmount: bigint;
+    deliveryKind: number;
+    escrowFlushedToRouting: boolean;
+  }> {
+    const result = await this.publicClient.readContract({
+      address: this.diamondAddress,
+      abi: DIAMOND_ABI,
+      functionName: 'quoteFill',
+      args: [orderId],
+    }) as {
+      payToken: Address;
+      price: bigint;
+      feeBps: number;
+      feeAmount: bigint;
+      feeReceiver: Address;
+      proceeds: bigint;
+      seller: Address;
+      sellToken: Address;
+      sellAmount: bigint;
+      deliveryKind: number;
+      escrowFlushedToRouting: boolean;
+    };
+
+    return result;
+  }
+
+  /**
+   * Get next order ID (also indicates total orders created)
+   */
+  async getNextOrderId(): Promise<bigint> {
+    const result = await this.publicClient.readContract({
+      address: this.diamondAddress,
+      abi: DIAMOND_ABI,
+      functionName: 'nextOrderId',
+      args: [],
+    });
+
+    return result as bigint;
+  }
+
+  /**
+   * Get orders by seller with pagination
+   */
+  async getOrdersBySeller(
+    seller: Address,
+    offset = 0,
+    limit = 100
+  ): Promise<OrderInfo[]> {
+    const result = await this.publicClient.readContract({
+      address: this.diamondAddress,
+      abi: DIAMOND_ABI,
+      functionName: 'ordersOf',
+      args: [seller, BigInt(offset), BigInt(limit)],
+    }) as unknown as OrderStruct[];
+
+    return result.map((order) => this.parseOrderInfo(order));
+  }
+
+  /**
+   * Get orders for a campaign
+   */
+  async getOrdersForCampaign(campaignId: bigint): Promise<{
+    activeOrderId: bigint;
+    historicalOrderIds: bigint[];
+  }> {
+    const result = await this.publicClient.readContract({
+      address: this.diamondAddress,
+      abi: DIAMOND_ABI,
+      functionName: 'ordersByCampaign',
+      args: [campaignId],
+    }) as { activeOrderId: bigint; historicalOrderIds: bigint[] };
+
+    return result;
+  }
+
+  /**
+   * Get active order for a campaign
+   */
+  async getActiveOrderForCampaign(campaignId: bigint): Promise<bigint> {
+    const result = await this.publicClient.readContract({
+      address: this.diamondAddress,
+      abi: DIAMOND_ABI,
+      functionName: 'getActiveOrderForCampaign',
+      args: [campaignId],
+    });
+
+    return result as bigint;
+  }
+
+  /**
+   * Preview available amount to sell for a campaign
+   */
+  async previewAvailableToSell(campaignId: bigint): Promise<{
+    futureUnlockable: bigint;
+    claimableNow: bigint;
+    asOf: number;
+  }> {
+    const result = await this.publicClient.readContract({
+      address: this.diamondAddress,
+      abi: DIAMOND_ABI,
+      functionName: 'previewAvailableToSell',
+      args: [campaignId],
+    }) as { futureUnlockable: bigint; claimableNow: bigint; asOf: bigint };
+
+    return {
+      futureUnlockable: result.futureUnlockable,
+      claimableNow: result.claimableNow,
+      asOf: Number(result.asOf),
+    };
+  }
+
+  /**
+   * Get all open orders
+   */
+  async getOpenOrders(limit = 100): Promise<OrderInfo[]> {
+    const nextId = await this.getNextOrderId();
+    const orders: OrderInfo[] = [];
+
+    for (let i = 0n; i < nextId && orders.length < limit; i++) {
+      try {
+        const order = await this.getOrder(i);
+        if (order.status === 'open') {
+          orders.push(order);
+        }
+      } catch {
+        // Order may not exist, skip
+      }
+    }
+
+    return orders;
+  }
+
+  // ============================================================================
+  // Validation
+  // ============================================================================
+
+  /**
+   * Check if trading is allowed for a campaign
+   */
+  async isTradingEnabled(campaignId: bigint): Promise<boolean> {
+    const result = await this.publicClient.readContract({
+      address: this.diamondAddress,
+      abi: DIAMOND_ABI,
+      functionName: 'isTradeLocked',
+      args: [campaignId],
+    });
+    return !(result as boolean);
+  }
+
+  // ============================================================================
+  // Trade Policy (Creator Functions)
+  // ============================================================================
+
+  /**
+   * Lock trading for a campaign (creator only)
+   *
+   * Prevents new orders from being created for this campaign.
+   */
+  async lockTrading(campaignId: bigint): Promise<TransactionResult> {
+    const wallet = this.requireWallet();
+
+    const hash = await wallet.writeContract({
+      chain: wallet.chain,
+      account: wallet.account!,
+      address: this.diamondAddress,
+      abi: DIAMOND_ABI,
+      functionName: 'setTradeLocked',
+      args: [campaignId, true],
+    });
+
+    return this.createTransactionResult(hash);
+  }
+
+  /**
+   * Unlock trading for a campaign (creator only)
+   */
+  async unlockTrading(campaignId: bigint): Promise<TransactionResult> {
+    const wallet = this.requireWallet();
+
+    const hash = await wallet.writeContract({
+      chain: wallet.chain,
+      account: wallet.account!,
+      address: this.diamondAddress,
+      abi: DIAMOND_ABI,
+      functionName: 'setTradeLocked',
+      args: [campaignId, false],
+    });
+
+    return this.createTransactionResult(hash);
+  }
+
+  // ============================================================================
+  // Utility Functions
+  // ============================================================================
+
+  /**
+   * Calculate total price for a given amount at price per token
+   */
+  calculateTotalPrice(amount: bigint, pricePerToken: bigint): bigint {
+    return (amount * pricePerToken) / BigInt(1e18);
+  }
+
+  /**
+   * Check if payment is in native token (ETH/BNB/etc)
+   */
+  isNativePayment(payToken: Address): boolean {
+    return payToken === zeroAddress;
+  }
+
+  // ============================================================================
+  // Helpers
+  // ============================================================================
+
+  private requireWallet(): WalletClient {
+    if (!this.walletClient) {
+      throw new Error(
+        'Wallet client required for write operations. Initialize SDK with a signer.'
+      );
+    }
+    return this.walletClient;
+  }
+
+  private parseOrderInfo(order: OrderStruct): OrderInfo {
+    const orderTypeMap: Record<number, OrderType> = {
+      0: 'instant',
+      1: 'vested',
+      2: 'tradable',
+    };
+
+    const statusMap: Record<number, OrderInfo['status']> = {
+      0: 'open',
+      1: 'filled',
+      2: 'canceled',
+      3: 'expired',
+    };
+
+    const result: OrderInfo = {
+      id: order.id,
+      orderType: orderTypeMap[order.kind] ?? 'instant',
+      seller: order.seller,
+      sellToken: order.sellToken,
+      sellAmount: order.sellAmount,
+      payToken: order.payToken,
+      totalPrice: order.price,
+      pricePerToken: order.sellAmount > 0n
+        ? (order.price * BigInt(1e18)) / order.sellAmount
+        : 0n,
+      status: statusMap[order.status] ?? 'open',
+      createdAt: 0, // Not stored in Order struct
+      expiresAt: Number(order.expiry),
+    };
+
+    // Add optional fields only if they have values
+    if (order.campaignId > 0n) {
+      result.campaignId = order.campaignId;
+    }
+    if (order.vest.durationSec > 0) {
+      result.vestingDuration = order.vest.durationSec;
+    }
+    if (order.vest.cliffBps > 0) {
+      result.cliffDuration = Math.floor((order.vest.durationSec * order.vest.cliffBps) / 10000);
+    }
+
+    return result;
+  }
+
+  private createTransactionResult(hash: Hash): TransactionResult {
+    return {
+      hash,
+      wait: async () => {
+        const receipt = await this.publicClient.waitForTransactionReceipt({
+          hash,
+        });
+        return {
+          blockNumber: receipt.blockNumber,
+          transactionHash: receipt.transactionHash,
+          gasUsed: receipt.gasUsed,
+          status: receipt.status,
+          logs: receipt.logs,
+        };
+      },
+    };
+  }
+}
+
+/**
+ * Order struct matching contract
+ */
+interface OrderStruct {
+  id: bigint;
+  seller: Address;
+  payToken: Address;
+  price: bigint;
+  kind: number;
+  sellToken: Address;
+  sellAmount: bigint;
+  campaignId: bigint;
+  visibility: number;
+  allowedBuyers: readonly Address[];
+  expiry: bigint;
+  status: number;
+  vest: {
+    startMode: number;
+    startAt: bigint;
+    durationSec: number;
+    stepSec: number;
+    cliffBps: number;
+  };
+  listedBehaviour: number;
+  escrowRouting: Address;
+}
+
+export default MarketplaceModule;