api: update types in the Loop and Pool API classes

Author: jamaljsr

app/src/api/loop.ts

@@ -59,7 +59,7 @@ class LoopApi extends BaseApi<LoopEvents> {
     confTarget?: number,
   ): Promise<LOOP.InQuoteResponse.AsObject> {
     const req = new LOOP.QuoteRequest();
-    req.setAmt(+amount);
+    req.setAmt(amount.toString());
     if (confTarget) req.setConfTarget(confTarget);
     const res = await this._grpc.request(SwapClient.GetLoopInQuote, req, this._meta);
     return res.toObject();
@@ -73,7 +73,7 @@ class LoopApi extends BaseApi<LoopEvents> {
     confTarget?: number,
   ): Promise<LOOP.OutQuoteResponse.AsObject> {
     const req = new LOOP.QuoteRequest();
-    req.setAmt(+amount);
+    req.setAmt(amount.toString());
     if (confTarget) req.setConfTarget(confTarget);
     const res = await this._grpc.request(SwapClient.LoopOutQuote, req, this._meta);
     return res.toObject();
@@ -89,9 +89,9 @@ class LoopApi extends BaseApi<LoopEvents> {
     confTarget?: number,
   ): Promise<LOOP.SwapResponse.AsObject> {
     const req = new LOOP.LoopInRequest();
-    req.setAmt(+amount);
-    req.setMaxSwapFee(+quote.swapFee);
-    req.setMaxMinerFee(+quote.minerFee);
+    req.setAmt(amount.toString());
+    req.setMaxSwapFee(quote.swapFee.toString());
+    req.setMaxMinerFee(quote.minerFee.toString());
     req.setInitiator(LOOP_INITIATOR);
     if (lastHop) req.setLastHop(b64(lastHop));
     if (confTarget) req.setHtlcConfTarget(confTarget);
@@ -105,20 +105,20 @@ class LoopApi extends BaseApi<LoopEvents> {
   async loopOut(
     amount: Big,
     quote: Quote,
-    chanIds: number[],
+    chanIds: string[],
     deadline: number,
     confTarget?: number,
     destAddress?: string,
   ): Promise<LOOP.SwapResponse.AsObject> {
     const req = new LOOP.LoopOutRequest();
-    req.setAmt(+amount);
-    req.setMaxSwapFee(+quote.swapFee);
-    req.setMaxMinerFee(+quote.minerFee);
-    req.setMaxPrepayAmt(+quote.prepayAmount);
-    req.setMaxSwapRoutingFee(this._calcRoutingFee(+amount));
-    req.setMaxPrepayRoutingFee(this._calcRoutingFee(+quote.prepayAmount));
-    req.setOutgoingChanSetList(chanIds);
-    req.setSwapPublicationDeadline(deadline);
+    req.setAmt(amount.toString());
+    req.setMaxSwapFee(quote.swapFee.toString());
+    req.setMaxMinerFee(quote.minerFee.toString());
+    req.setMaxPrepayAmt(quote.prepayAmount.toString());
+    req.setMaxSwapRoutingFee(this._calcRoutingFee(amount).toString());
+    req.setMaxPrepayRoutingFee(this._calcRoutingFee(quote.prepayAmount).toString());
+    req.setOutgoingChanSetList(chanIds.map(id => id.toString()));
+    req.setSwapPublicationDeadline(deadline.toString());
     req.setInitiator(LOOP_INITIATOR);
     if (confTarget) req.setSweepConfTarget(confTarget);
     if (destAddress) req.setDest(destAddress);
@@ -138,15 +138,16 @@ class LoopApi extends BaseApi<LoopEvents> {
       this._meta,
     );
   }
+
   /**
    * Calculates the max routing fee params for loop out. this mimics the loop cli
    * behavior of using 2% of the amount
    * @param amount the amount of the payment
    */
-  private _calcRoutingFee(amount: number) {
-    const routingFeePct = 2;
+  private _calcRoutingFee(amount: Big): Big {
+    const routingFeeFactor = 0.02;
     // round up to avoid decimals
-    return Math.ceil(amount * (routingFeePct / 100));
+    return amount.mul(routingFeeFactor).round(0, Big.roundUp);
   }
 }
 

app/src/api/pool.ts

@@ -1,6 +1,7 @@
 import * as AUCT from 'types/generated/auctioneerrpc/auctioneer_pb';
 import * as POOL from 'types/generated/trader_pb';
 import { Trader } from 'types/generated/trader_pb_service';
+import Big from 'big.js';
 import { b64 } from 'util/strings';
 import { OrderType, Tier } from 'store/models/order';
 import BaseApi from './base';
@@ -43,11 +44,11 @@ class PoolApi extends BaseApi<PoolEvents> {
    * call the pool `QuoteAccount` RPC and return the response
    */
   async quoteAccount(
-    amount: number,
+    amount: Big,
     confTarget: number,
   ): Promise<POOL.QuoteAccountResponse.AsObject> {
     const req = new POOL.QuoteAccountRequest();
-    req.setAccountValue(amount);
+    req.setAccountValue(amount.toString());
     req.setConfTarget(confTarget);
     const res = await this._grpc.request(Trader.QuoteAccount, req, this._meta);
     return res.toObject();
@@ -57,12 +58,12 @@ class PoolApi extends BaseApi<PoolEvents> {
    * call the pool `InitAccount` RPC and return the response
    */
   async initAccount(
-    amount: number,
+    amount: Big,
     expiryBlocks: number,
     confTarget = 6,
   ): Promise<POOL.Account.AsObject> {
     const req = new POOL.InitAccountRequest();
-    req.setAccountValue(amount);
+    req.setAccountValue(amount.toString());
     req.setRelativeHeight(expiryBlocks);
     req.setConfTarget(confTarget);
     req.setInitiator(POOL_INITIATOR);
@@ -76,12 +77,12 @@ class PoolApi extends BaseApi<PoolEvents> {
   async renewAccount(
     traderKey: string,
     expiryBlocks: number,
-    feeRateSatPerKw: number,
+    feeRateSatPerKw: Big,
   ): Promise<POOL.RenewAccountResponse.AsObject> {
     const req = new POOL.RenewAccountRequest();
     req.setAccountKey(b64(traderKey));
     req.setRelativeExpiry(expiryBlocks);
-    req.setFeeRateSatPerKw(feeRateSatPerKw);
+    req.setFeeRateSatPerKw(feeRateSatPerKw.toString());
 
     const res = await this._grpc.request(Trader.RenewAccount, req, this._meta);
     return res.toObject();
@@ -99,7 +100,7 @@ class PoolApi extends BaseApi<PoolEvents> {
     req.setTraderKey(b64(traderKey));
 
     const output = new POOL.OutputWithFee();
-    output.setFeeRateSatPerKw(feeRateSatPerKw);
+    output.setFeeRateSatPerKw(feeRateSatPerKw.toString());
     if (destinationAddr) {
       output.setAddress(destinationAddr);
     }
@@ -123,13 +124,13 @@ class PoolApi extends BaseApi<PoolEvents> {
    */
   async deposit(
     traderKey: string,
-    amount: number,
+    amount: Big,
     feeRateSatPerKw = 253,
   ): Promise<POOL.DepositAccountResponse.AsObject> {
     const req = new POOL.DepositAccountRequest();
     req.setTraderKey(Buffer.from(traderKey, 'hex').toString('base64'));
-    req.setAmountSat(amount);
-    req.setFeeRateSatPerKw(feeRateSatPerKw);
+    req.setAmountSat(amount.toString());
+    req.setFeeRateSatPerKw(feeRateSatPerKw.toString());
     const res = await this._grpc.request(Trader.DepositAccount, req, this._meta);
     return res.toObject();
   }
@@ -139,14 +140,14 @@ class PoolApi extends BaseApi<PoolEvents> {
    */
   async withdraw(
     traderKey: string,
-    amount: number,
+    amount: Big,
     feeRateSatPerKw = 253,
   ): Promise<POOL.WithdrawAccountResponse.AsObject> {
     const req = new POOL.WithdrawAccountRequest();
     req.setTraderKey(Buffer.from(traderKey, 'hex').toString('base64'));
-    req.setFeeRateSatPerKw(feeRateSatPerKw);
+    req.setFeeRateSatPerKw(feeRateSatPerKw.toString());
     const output = new POOL.Output();
-    output.setValueSat(amount);
+    output.setValueSat(amount.toString());
     req.setOutputsList([output]);
     const res = await this._grpc.request(Trader.WithdrawAccount, req, this._meta);
     return res.toObject();
@@ -165,18 +166,18 @@ class PoolApi extends BaseApi<PoolEvents> {
    * call the pool `QuoteOrder` RPC and return the response
    */
   async quoteOrder(
-    amount: number,
+    amount: Big,
     rateFixed: number,
     duration: number,
     minUnitsMatch: number,
-    feeRateSatPerKw: number,
+    feeRateSatPerKw = 253,
   ): Promise<POOL.QuoteOrderResponse.AsObject> {
     const req = new POOL.QuoteOrderRequest();
-    req.setAmt(amount);
+    req.setAmt(amount.toString());
     req.setRateFixed(rateFixed);
     req.setLeaseDurationBlocks(duration);
     req.setMinUnitsMatch(minUnitsMatch);
-    req.setMaxBatchFeeRateSatPerKw(feeRateSatPerKw);
+    req.setMaxBatchFeeRateSatPerKw(feeRateSatPerKw.toString());
 
     const res = await this._grpc.request(Trader.QuoteOrder, req, this._meta);
     return res.toObject();
@@ -188,11 +189,11 @@ class PoolApi extends BaseApi<PoolEvents> {
   async submitOrder(
     traderKey: string,
     type: OrderType,
-    amount: number,
+    amount: Big,
     rateFixed: number,
     duration: number,
     minUnitsMatch: number,
-    feeRateSatPerKw: number,
+    feeRateSatPerKw = 253,
     minNodeTier?: Tier,
   ): Promise<POOL.SubmitOrderResponse.AsObject> {
     if (rateFixed < 1) {
@@ -204,10 +205,10 @@ class PoolApi extends BaseApi<PoolEvents> {
 
     const order = new POOL.Order();
     order.setTraderKey(b64(traderKey));
-    order.setAmt(amount);
+    order.setAmt(amount.toString());
     order.setRateFixed(rateFixed);
     order.setMinUnitsMatch(minUnitsMatch);
-    order.setMaxBatchFeeRateSatPerKw(feeRateSatPerKw);
+    order.setMaxBatchFeeRateSatPerKw(feeRateSatPerKw.toString());
 
     switch (type) {
       case OrderType.Bid:
@@ -324,36 +325,37 @@ class PoolApi extends BaseApi<PoolEvents> {
    * Converts from sats per kilo-weight to sats per vByte
    * @param satsPerVByte the number of sats per kilo-weight
    */
-  satsPerKWeightToVByte(satsPerKWeight: number) {
+  satsPerKWeightToVByte(satsPerKWeight: Big) {
     // convert to kilo-vbyte
-    const satsPerKVByte = satsPerKWeight * 4;
+    const satsPerKVByte = satsPerKWeight.mul(4);
     // convert to vbyte
-    return satsPerKVByte / 1000;
+    return satsPerKVByte.div(1000);
   }
 
   /**
    * Calculates the per block fixed rate given an amount and premium
    * @param amount the amount of the order
    * @param premium the premium being paid
+   * @param duration the lease duration in blocks
    */
-  calcFixedRate(amount: number, premium: number, duration: number) {
-    const ratePct = (premium * 100) / amount;
+  calcFixedRate(amount: Big, premium: Big, duration: number) {
+    const ratePct = premium.mul(100).div(amount);
     // rate = % / 100
     // rate = rateFixed / totalParts
     // rateFixed = rate * totalParts
-    const interestRate = ratePct / 100;
-    const rateFixedFloat = interestRate * FEE_RATE_TOTAL_PARTS;
+    const interestRate = ratePct.div(100);
+    const rateFixedFloat = interestRate.mul(FEE_RATE_TOTAL_PARTS);
     // We then take this rate fixed, and divide it by the number of blocks
     // as the user wants this rate to be the final lump sum they pay.
-    return Math.floor(rateFixedFloat / duration);
+    return +rateFixedFloat.div(duration).round(0, Big.roundDown);
   }
 
   /**
    * Calculates the percentage interest rate for a given fixed rate
    * @param fixedRate the per block fixed rate
    */
-  calcPctRate(fixedRate: number, duration: number) {
-    return (fixedRate * duration) / FEE_RATE_TOTAL_PARTS;
+  calcPctRate(fixedRate: Big, duration: Big) {
+    return +fixedRate.mul(duration).div(FEE_RATE_TOTAL_PARTS);
   }
 }