Deal Management

interface SubjectReference {
  type: string;  // e.g., "NFT", "SERVICE", "ORDER"
  id: string;    // e.g., "nft-123", "order-456"
}

// Examples
amount: "1000"     // 1000 units
amount: "250000"   // 250k units
amount: "0"        // Free service

const { deal_id } = await client.openDealAdmin({
  signer: adminWallet,
  admin_cap_id: adminCapability,
  party_b: customerWallet,
  subject_ref: {
    type: "ORDER",
    id: "ORD-2024-001"
  },
  amount: "15000"
});

const { deal_id } = await client.openDealClient({
  signer: userWallet,
  client_cap_id: userCapability,
  party_b: providerWallet,
  subject_ref: {
    type: "SERVICE",
    id: "web-design-project"
  },
  amount: "50000"
});

// Party B accepts the deal
await client.acceptDeal({
  signer: partyBWallet,
  deal_id: dealId
});

// Close the deal when work is completed
await client.closeDeal({
  signer: partyWallet, // Can be either party
  deal_id: dealId
});

// Good
subject_ref: {
  type: "NFT_MARKETPLACE_SALE",
  id: "cryptopunk-7804-sale-2024"
}

// Avoid
subject_ref: {
  type: "SALE",
  id: "123"
}

// For a $150 service (assuming token has 2 decimals)
amount: "15000"  // 150.00 in smallest units

// In your application logic
async function markOrderDelivered(orderId: string) {
  // Update your database
  await db.orders.update(orderId, { status: 'delivered' });
  
  // Close the reputation deal
  const order = await db.orders.findById(orderId);
  await reputationClient.closeDeal({
    signer: adminWallet,
    deal_id: order.reputationDealId
  });
}

try {
  await client.acceptDeal({ signer, deal_id });
} catch (error) {
  switch (error.code) {
    case 'DEAL_NOT_FOUND':
      console.error('Deal ID does not exist');
      break;
    case 'NOT_PARTY_B':
      console.error('Only Party B can accept this deal');
      break;
    case 'DEAL_ALREADY_ACCEPTED':
      console.error('Deal is already in ACTIVE state');
      break;
    case 'DEAL_ALREADY_CLOSED':
      console.error('Deal has been closed');
      break;
  }
}

class OrderService {
  async createOrder(buyerId: string, sellerId: string, productId: string, amount: number) {
    // Create order in your system
    const order = await this.db.orders.create({
      buyerId, sellerId, productId, amount,
      status: 'pending'
    });
    
    // Create reputation deal
    const dealResult = await this.reputation.openDealAdmin({
      signer: this.adminWallet,
      admin_cap_id: this.adminCap,
      party_b: buyerId,
      subject_ref: {
        type: 'ECOMMERCE_ORDER',
        id: order.id
      },
      amount: amount.toString()
    });
    
    // Link deal to order
    await this.db.orders.update(order.id, {
      reputationDealId: dealResult.deal_id
    });
    
    return order;
  }
}

class ServiceBooking {
  async bookService(clientId: string, providerId: string, serviceType: string, fee: number) {
    // Create booking
    const booking = await this.createBooking({
      clientId, providerId, serviceType, fee
    });
    
    // Auto-accept deal for service bookings
    const dealResult = await this.reputation.openDealClient({
      signer: clientId,
      client_cap_id: await this.getClientCap(clientId),
      party_b: providerId,
      subject_ref: {
        type: 'SERVICE_BOOKING',
        id: booking.id
      },
      amount: fee.toString()
    });
    
    // Auto-accept if provider is online
    if (await this.isProviderOnline(providerId)) {
      await this.reputation.acceptDeal({
        signer: providerId,
        deal_id: dealResult.deal_id
      });
    }
    
    return booking;
  }
}