feat: strengthen net payable amount logic

Author: Ang-dot

src/acpFare.ts

@@ -13,7 +13,18 @@ class Fare {
   constructor(public contractAddress: Address, public decimals: number) {}
 
   formatAmount(amount: number) {
-    return parseUnits(amount.toString(), this.decimals);
+    if (!Number.isFinite(amount) || amount < 0) {
+      throw new AcpError(
+        `Invalid amount: ${amount}. Amount must be a finite, non-negative number.`
+      );
+    }
+
+    const numStr = amount.toString();
+    const amountStr = numStr.includes('e')
+      ? amount.toFixed(this.decimals)
+      : numStr;
+
+    return parseUnits(amountStr, this.decimals);
   }
 
   static async fromContractAddress(

src/acpJob.ts

@@ -138,11 +138,33 @@ class AcpJob {
         ? this.baseFare.decimals
         : 18;
 
-    const formattedAmount = formatUnits(
-      payableMemo.payableDetails.amount,
-      decimals
-    );
+    const grossAmount = payableMemo.payableDetails.amount;
+    const minimumUnit = BigInt(1);
+
+    if (this.priceType === PriceType.PERCENTAGE) {
+      const feeBasisPoints = BigInt(Math.round(this.priceValue * 10000));
+      let feeAmount = (grossAmount * feeBasisPoints) / BigInt(10000);
+
+      if (feeBasisPoints > BigInt(0) && feeAmount === BigInt(0)) {
+        feeAmount = minimumUnit;
+      }
 
+      const netAmount = grossAmount - feeAmount;
+
+      const formattedNetAmount = formatUnits(netAmount, decimals);
+      const netAmountNumber = parseFloat(formattedNetAmount);
+
+      if (!Number.isFinite(netAmountNumber)) {
+        throw new AcpError(
+          `Net payable amount overflow: ${formattedNetAmount} exceeds safe number range`
+        );
+      }
+
+      const factor = Math.pow(10, decimals);
+      return Math.floor(netAmountNumber * factor) / factor;
+    }
+
+    const formattedAmount = formatUnits(grossAmount, decimals);
     const payableAmount = parseFloat(formattedAmount);
 
     if (!Number.isFinite(payableAmount)) {
@@ -157,17 +179,8 @@ class AcpJob {
       );
     }
 
-    if (this.priceType === PriceType.PERCENTAGE) {
-      const netAmount = payableAmount * (1 - this.priceValue);
-      if (!Number.isFinite(netAmount)) {
-        throw new AcpError(
-          `Net payable amount calculation overflow for percentage pricing`
-        );
-      }
-      return netAmount;
-    }
-
-    return payableAmount;
+    const factor = Math.pow(10, decimals);
+    return Math.floor(payableAmount * factor) / factor;
   }
 
   async createRequirement(content: string) {