fix: only log user settled amounts (#330)

* only log user outputs

* add unit test

* unit test

Author: ConjunctiveNormalForm

lib/entities/Order.ts

@@ -23,10 +23,10 @@ export type OrderOutput = {
 }
 
 export type SettledAmount = {
-  tokenOut?: string
-  amountOut?: string
-  tokenIn?: string
-  amountIn?: string
+  tokenOut: string
+  amountOut: string
+  tokenIn: string
+  amountIn: string
 }
 
 export type OrderEntity = {

lib/handlers/check-order-status/handler.ts

@@ -1,4 +1,5 @@
 import { DutchOrder, FillInfo, OrderValidation } from '@uniswap/uniswapx-sdk'
+
 import { Unit } from 'aws-embedded-metrics'
 import { default as Logger } from 'bunyan'
 import { ethers } from 'ethers'
@@ -95,7 +96,7 @@ export class CheckOrderStatusHandler extends SfnLambdaHandler<ContainerInjected,
             gasCostInETH,
             receipt.effectiveGasPrice.toString(),
             receipt.gasUsed.toString(),
-            settledAmounts
+            settledAmounts.reduce((prev, cur) => (prev && prev.amountOut > cur.amountOut ? prev : cur))
           )
 
           const percentDecayed = (timestamp - order.decayStartTime) / (order.decayEndTime - order.decayStartTime)
@@ -197,7 +198,7 @@ export class CheckOrderStatusHandler extends SfnLambdaHandler<ContainerInjected,
             gasCostInETH,
             receipt.effectiveGasPrice.toString(),
             receipt.gasUsed.toString(),
-            settledAmounts
+            settledAmounts.reduce((prev, cur) => (prev && prev.amountOut > cur.amountOut ? prev : cur))
           )
 
           const percentDecayed =
@@ -374,37 +375,35 @@ export class CheckOrderStatusHandler extends SfnLambdaHandler<ContainerInjected,
     gasCostInETH: string,
     gasPriceWei: string,
     gasUsed: string,
-    settledAmounts: SettledAmount[]
+    userAmount: SettledAmount
   ): void {
-    settledAmounts.forEach((settledAmount) => {
-      log.info({
-        orderInfo: {
-          orderStatus: ORDER_STATUS.FILLED,
-          orderHash: fill.orderHash,
-          quoteId: quoteId,
-          filler: fill.filler,
-          nonce: fill.nonce.toString(),
-          offerer: fill.swapper,
-          tokenIn: settledAmount.tokenIn,
-          amountIn: settledAmount.amountIn,
-          tokenOut: settledAmount.tokenOut,
-          amountOut: settledAmount.amountOut,
-          blockNumber: fill.blockNumber,
-          txHash: fill.txHash,
-          fillTimestamp: timestamp,
-          gasPriceWei: gasPriceWei,
-          gasUsed: gasUsed,
-          gasCostInETH: gasCostInETH,
-          logTime: Math.floor(Date.now() / 1000).toString(),
-        },
-      })
+    log.info({
+      orderInfo: {
+        orderStatus: ORDER_STATUS.FILLED,
+        orderHash: fill.orderHash,
+        quoteId: quoteId,
+        filler: fill.filler,
+        nonce: fill.nonce.toString(),
+        offerer: fill.swapper,
+        tokenIn: userAmount.tokenIn,
+        amountIn: userAmount.amountIn,
+        tokenOut: userAmount.tokenOut,
+        amountOut: userAmount.amountOut,
+        blockNumber: fill.blockNumber,
+        txHash: fill.txHash,
+        fillTimestamp: timestamp,
+        gasPriceWei: gasPriceWei,
+        gasUsed: gasUsed,
+        gasCostInETH: gasCostInETH,
+        logTime: Math.floor(Date.now() / 1000).toString(),
+      },
     })
   }
 
   public getSettledAmounts(fill: FillInfo, fillTimestamp: number, parsedOrder: DutchOrder): SettledAmount[] {
     const nativeOutputs = parsedOrder.info.outputs.filter((output) => output.token.toLowerCase() === NATIVE_ADDRESS)
     const settledAmounts: SettledAmount[] = []
-    let amountIn: string | undefined
+    let amountIn: string
     if (parsedOrder.info.input.endAmount.eq(parsedOrder.info.input.startAmount)) {
       // If the order is EXACT_INPUT then the input will not decay and resolves to the startAmount/endAmount.
       amountIn = parsedOrder.info.input.startAmount.toString()
@@ -428,10 +427,12 @@ export class CheckOrderStatusHandler extends SfnLambdaHandler<ContainerInjected,
     } else {
       // If the order is EXACT_OUTPUT we will have all the ERC20 transfers in the fill logs,
       // only log the amountIn that matches the order input token.
+
+      // eslint-disable-next-line  @typescript-eslint/no-non-null-assertion
       const input = fill.inputs.find(
         (input) => input.token.toLowerCase() === parsedOrder.info.input.token.toLowerCase()
-      )
-      amountIn = input?.amount.toString()
+      )!
+      amountIn = input.amount.toString()
 
       // Add all the native outputs to the settledAmounts as they are not included in the fill logs.
       // The amount is just the startAmount because the order is EXACT_OUTPUT so there is no decay on the outputs.

test/handlers/check-order-status.test.ts

@@ -55,6 +55,7 @@ describe('Testing check order status handler', () => {
   const getByHashMock = jest.fn().mockReturnValue(MOCK_ORDER_ENTITY)
   const updateOrderStatusMock = jest.fn().mockReturnValue(Promise<void>)
   const providerMock = jest.fn().mockReturnValue(mockedBlockNumber)
+  const getTransactionMock = jest.fn()
 
   const buildInjectorPromiseMock = (retryCount: number, orderStatus: string) => {
     return {
@@ -82,6 +83,10 @@ describe('Testing check order status handler', () => {
           },
           provider: {
             getBlockNumber: providerMock,
+            getTransaction: getTransactionMock,
+            getBlock: () => Promise.resolve({
+              timestamp: 123456
+            })
           },
         }
       },
@@ -154,6 +159,58 @@ describe('Testing check order status handler', () => {
       })
     })
 
+    it('should check fill events when order expired', async () => {
+      const checkorderStatusHandler = new CheckOrderStatusHandler('check-order-status', initialInjectorPromiseMock)
+      validateMock.mockReturnValue(OrderValidation.Expired)
+      getTransactionMock.mockReturnValueOnce({
+        wait: () => Promise.resolve({
+          effectiveGasPrice: BigNumber.from(1),
+          gasUsed: 100
+        })
+      })
+      getFillInfoMock.mockReturnValue([{
+        orderHash: MOCK_ORDER_HASH,
+        filler: '0x123',
+        nonce: BigNumber.from(1),
+        swapper: '0x123',
+        blockNumber: 12321312313,
+        txHash: '0x1244345323',
+        inputs: [{token: 'USDC', amount: BigNumber.from(100)}],
+        outputs: [{token: 'WETH', amount: BigNumber.from(1)}],
+      }])
+      
+      expect(await checkorderStatusHandler.handler(handlerEventMock)).toMatchObject({
+        orderStatus: ORDER_STATUS.FILLED,
+      })
+      expect(getFillInfoMock).toBeCalled()
+    })
+
+    it('should check fill events when nonceUsed', async () => {
+      const checkorderStatusHandler = new CheckOrderStatusHandler('check-order-status', initialInjectorPromiseMock)
+      validateMock.mockReturnValue(OrderValidation.NonceUsed)
+      getTransactionMock.mockReturnValueOnce({
+        wait: () => Promise.resolve({
+          effectiveGasPrice: BigNumber.from(1),
+          gasUsed: 100
+        })
+      })
+      getFillInfoMock.mockReturnValue([{
+        orderHash: MOCK_ORDER_HASH,
+        filler: '0x123',
+        nonce: BigNumber.from(1),
+        swapper: '0x123',
+        blockNumber: 12321312313,
+        txHash: '0x1244345323',
+        inputs: [{token: 'USDC', amount: BigNumber.from(100)}],
+        outputs: [{token: 'WETH', amount: BigNumber.from(1)}],
+      }])
+      
+      expect(await checkorderStatusHandler.handler(handlerEventMock)).toMatchObject({
+        orderStatus: ORDER_STATUS.FILLED,
+      })
+      expect(getFillInfoMock).toBeCalled()
+    })
+
     it('should return insufficient-funds order status', async () => {
       const checkorderStatusHandler = new CheckOrderStatusHandler('check-order-status', initialInjectorPromiseMock)
       validateMock.mockReturnValue(OrderValidation.InsufficientFunds)