Dutchv3 (#490)

* Add Dutchv3 support

* Make missing env vars easier to find

* First test working

* Remove dutchV2 filter

* more tests

* Moar tests

* All the tests

* Add tests/check for min/max amounts

* Address PR feedback

* Update yarn.lock

* Fix lint

* Add override validation

* lint fixes

* Resolve Dutchv3 amounts

* Add deadline explicitly to test

* Use 0x00... as valid cosigner

* Fix EXACT_INPUT check

Author: codyborn

bin/stacks/step-function-stack.ts

@@ -62,14 +62,20 @@ export class StepFunctionStack extends cdk.NestedStack {
     // TODO: remove the if block after accounts are set up for parameterization-api
     if (props.envVars['FILL_EVENT_DESTINATION_ARN']) {
       new aws_logs.CfnSubscriptionFilter(this, 'TerminalStateSub', {
-        destinationArn: checkDefined(props.envVars['FILL_EVENT_DESTINATION_ARN']),
+        destinationArn: checkDefined(
+          props.envVars['FILL_EVENT_DESTINATION_ARN'],
+          'FILL_EVENT_DESTINATION_ARN is undefined'
+        ),
         // filter patterns should match ORDER_STATUS.FILLED, ORDER_STATUS.CANCELLED
         filterPattern: '{ $.orderInfo.orderStatus = "filled" || $.orderInfo.orderStatus = "cancelled" }',
         logGroupName: checkStatusFunction.logGroup.logGroupName,
       })
 
       new aws_logs.CfnSubscriptionFilter(this, 'nonTerminalSub', {
-        destinationArn: checkDefined(props.envVars['ACTIVE_ORDER_EVENT_DESTINATION_ARN']),
+        destinationArn: checkDefined(
+          props.envVars['ACTIVE_ORDER_EVENT_DESTINATION_ARN'],
+          'ACTIVE_ORDER_EVENT_DESTINATION_ARN is undefined'
+        ),
         filterPattern: '{ $.orderInfo.orderStatus = "insufficient-funds" }',
         logGroupName: checkStatusFunction.logGroup.logGroupName,
       })

lib/entities/Order.ts

@@ -15,6 +15,14 @@ export type OrderInput = {
   endAmount?: string
 }
 
+export type V3OrderInput = {
+  token: string
+  startAmount: string
+  curve?: NonlinearDutchDecay
+  maxAmount: string
+  adjustmentPerGweiBaseFee: string
+}
+
 export type PriorityOrderInput = {
   token: string
   amount: string
@@ -28,6 +36,20 @@ export type OrderOutput = {
   recipient: string
 }
 
+export type V3OrderOutput = {
+  token: string
+  startAmount: string
+  curve: NonlinearDutchDecay
+  recipient: string
+  minAmount: string
+  adjustmentPerGweiBaseFee: string
+}
+
+export type NonlinearDutchDecay = {
+  relativeBlocks: number[]
+  relativeAmounts: string[]
+}
+
 export type PriorityOrderOutput = {
   token: string
   amount: string
@@ -88,6 +110,20 @@ export type DutchV2OrderEntity = SharedXOrderEntity & {
   cosignature: string
 }
 
+export type DutchV3OrderEntity = SharedXOrderEntity & {
+  type: OrderType.Dutch_V3
+  input: V3OrderInput
+  outputs: V3OrderOutput[]
+  startingBaseFee: string
+  cosignerData: {
+    decayStartBlock: number
+    exclusiveFiller: string
+    inputOverride: string
+    outputOverrides: string[]
+  }
+  cosignature: string
+}
+
 export type PriorityOrderEntity = SharedXOrderEntity & {
   type: OrderType.Priority
   auctionStartBlock: number
@@ -100,9 +136,9 @@ export type PriorityOrderEntity = SharedXOrderEntity & {
   cosignature: string
 }
 
-// Db representation of Dutch V1, Dutch V2, or Limit Order
+// Db representation of Dutch V1, Dutch V2, Dutch V3, or Limit Order
 // indexes are returned at runtime but not represented on this type. Ideally we will include a mapping at repo layer boundary
-export type UniswapXOrderEntity = DutchV1OrderEntity | DutchV2OrderEntity | PriorityOrderEntity
+export type UniswapXOrderEntity = DutchV1OrderEntity | DutchV2OrderEntity | PriorityOrderEntity | DutchV3OrderEntity
 
 export enum SORT_FIELDS {
   CREATED_AT = 'createdAt',
@@ -112,6 +148,10 @@ export function isPriorityOrderEntity(order: UniswapXOrderEntity): order is Prio
   return order.type === OrderType.Priority
 }
 
+export function isDutchV3OrderEntity(order: UniswapXOrderEntity): order is DutchV3OrderEntity {
+  return order.type === OrderType.Dutch_V3
+}
+
 export function isDutchV2OrderEntity(order: UniswapXOrderEntity): order is DutchV2OrderEntity {
   return order.type === OrderType.Dutch_V2
 }

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

@@ -66,7 +66,7 @@ export class CheckOrderStatusHandler extends SfnLambdaHandler<ContainerInjected,
         stateMachineArn: input.requestInjected.stateMachineArn,
       }
     } else {
-      // Dutch, Dutch_V2, Priority
+      // Dutch, Dutch_V2, Dutch_V3, Priority
       const response = await this.checkOrderStatusService.handleRequest(input.requestInjected)
       return {
         ...response,

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

@@ -1,6 +1,7 @@
 import {
   CosignedPriorityOrder,
   CosignedV2DutchOrder,
+  CosignedV3DutchOrder,
   DutchOrder,
   FillInfo,
   OrderType,
@@ -81,6 +82,9 @@ export class CheckOrderStatusService {
       case OrderType.Dutch_V2:
         parsedOrder = CosignedV2DutchOrder.parse(order.encodedOrder, chainId)
         break
+      case OrderType.Dutch_V3:
+        parsedOrder = CosignedV3DutchOrder.parse(order.encodedOrder, chainId)
+        break
       case OrderType.Priority:
         parsedOrder = CosignedPriorityOrder.parse(order.encodedOrder, chainId)
         break
@@ -133,7 +137,7 @@ export class CheckOrderStatusService {
             maxPriorityFeePerGas: tx.maxPriorityFeePerGas,
             maxFeePerGas: tx.maxFeePerGas,
           },
-          parsedOrder as DutchOrder | CosignedV2DutchOrder | CosignedPriorityOrder
+          parsedOrder as DutchOrder | CosignedV2DutchOrder | CosignedV3DutchOrder | CosignedPriorityOrder
         )
 
         await this.fillEventLogger.processFillEvent({

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

@@ -1,6 +1,7 @@
 import {
   CosignedPriorityOrder,
   CosignedV2DutchOrder,
+  CosignedV3DutchOrder,
   DutchOrder,
   FillInfo,
   OrderType,
@@ -25,10 +26,12 @@ export interface FillMetadata {
 export function getSettledAmounts(
   fill: FillInfo,
   metadata: FillMetadata,
-  parsedOrder: DutchOrder | CosignedV2DutchOrder | CosignedPriorityOrder
+  parsedOrder: DutchOrder | CosignedV2DutchOrder | CosignedV3DutchOrder | CosignedPriorityOrder
 ) {
   if (parsedOrder instanceof DutchOrder || parsedOrder instanceof CosignedV2DutchOrder) {
     return getDutchSettledAmounts(fill, metadata.timestamp, parsedOrder)
+  } else if (parsedOrder instanceof CosignedV3DutchOrder) {
+    return getDutchV3SettledAmounts(fill, parsedOrder)
   } else if (parsedOrder instanceof CosignedPriorityOrder) {
     return getPrioritySettledAmounts(fill, metadata, parsedOrder)
   } else {
@@ -95,6 +98,73 @@ export function getPrioritySettledAmounts(
   return settledAmounts
 }
 
+/**
+ * get the ammounts transfered on chain
+ * used for logging
+ */
+export function getDutchV3SettledAmounts(
+  fill: FillInfo,
+  parsedOrder: CosignedV3DutchOrder
+): SettledAmount[] {
+  parsedOrder.resolve({currentBlock: fill.blockNumber})
+  const nativeOutputs = parsedOrder.info.outputs.filter((output) => output.token.toLowerCase() === NATIVE_ADDRESS)
+  const settledAmounts: SettledAmount[] = []
+  let amountIn: string
+
+  if (!parsedOrder.info.input.curve || 
+    (parsedOrder.info.input.curve.relativeAmounts.length === 1 && 
+    parsedOrder.info.input.curve.relativeAmounts[0] === BigInt(0))) {
+    // If the order is EXACT_INPUT then the input will not decay and resolves to the startAmount/endAmount.
+    amountIn = parsedOrder.info.input.startAmount.toString()
+
+    // Resolve the native outputs using the fill block number and filler address from the fill log.
+    // This will give us a minimum resolved amount for native out swaps.
+    const resolvedOrder = parsedOrder.resolve({ currentBlock: fill.blockNumber, filler: fill.filler })
+    const resolvedNativeOutputs = resolvedOrder.outputs.filter(
+      (output) => output.token.toLowerCase() === NATIVE_ADDRESS
+    )
+
+    // Add all the resolved native outputs to the settledAmounts as they are not included in the fill logs.
+    resolvedNativeOutputs.forEach((resolvedNativeOutput) => {
+      settledAmounts.push({
+        tokenIn: parsedOrder.info.input.token,
+        amountIn,
+        tokenOut: resolvedNativeOutput.token,
+        amountOut: resolvedNativeOutput.amount.toString(),
+      })
+    })
+  } 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()
+
+    // 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.
+    nativeOutputs.forEach((nativeOutput) => {
+      settledAmounts.push({
+        tokenIn: parsedOrder.info.input.token,
+        amountIn,
+        tokenOut: nativeOutput.token,
+        amountOut: nativeOutput.startAmount.toString(),
+      })
+    })
+  }
+
+  fill.outputs.forEach((output) => {
+    settledAmounts.push({
+      tokenIn: parsedOrder.info.input.token,
+      amountIn,
+      tokenOut: output.token,
+      amountOut: output.amount.toString(),
+    })
+  })
+
+  return settledAmounts
+}
+
 /**
  * get the ammounts transfered on chain
  * used for logging

lib/handlers/get-orders/handler.ts

@@ -1,6 +1,4 @@
 import Joi from 'joi'
-
-import { OrderType } from '@uniswap/uniswapx-sdk'
 import { Unit } from 'aws-embedded-metrics'
 import { APIGatewayProxyEvent, APIGatewayProxyResult, Context } from 'aws-lambda'
 import { UniswapXOrderEntity } from '../../entities'
@@ -21,14 +19,15 @@ import { GetOrdersResponse, GetOrdersResponseJoi } from './schema/GetOrdersRespo
 import { GetPriorityOrderResponse } from './schema/GetPriorityOrderResponse'
 import { GetRelayOrderResponse, GetRelayOrdersResponseJoi } from './schema/GetRelayOrderResponse'
 import { GetOrdersQueryParams, GetOrdersQueryParamsJoi, RawGetOrdersQueryParams } from './schema/index'
+import { GetDutchV3OrderResponse } from './schema/GetDutchV3OrderResponse'
 
 export class GetOrdersHandler extends APIGLambdaHandler<
   ContainerInjected,
   RequestInjected,
   void,
   RawGetOrdersQueryParams,
   GetOrdersResponse<
-    UniswapXOrderEntity | GetDutchV2OrderResponse | GetRelayOrderResponse | GetPriorityOrderResponse | undefined
+    UniswapXOrderEntity | GetDutchV2OrderResponse | GetDutchV3OrderResponse | GetRelayOrderResponse | GetPriorityOrderResponse | undefined
   >
 > {
   constructor(
@@ -44,13 +43,13 @@ export class GetOrdersHandler extends APIGLambdaHandler<
   ): Promise<
     | Response<
         GetOrdersResponse<
-          UniswapXOrderEntity | GetDutchV2OrderResponse | GetRelayOrderResponse | GetPriorityOrderResponse | undefined
+          UniswapXOrderEntity | GetDutchV2OrderResponse | GetDutchV3OrderResponse | GetRelayOrderResponse | GetPriorityOrderResponse | undefined
         >
       >
     | ErrorResponse
   > {
     const {
-      requestInjected: { limit, queryFilters, cursor, includeV2, orderType },
+      requestInjected: { limit, queryFilters, cursor, orderType },
       containerInjected: { dbInterface },
     } = params
 
@@ -72,9 +71,6 @@ export class GetOrdersHandler extends APIGLambdaHandler<
 
       //without orderType specified, keep legacy implementation
       const getOrdersResult = await dbInterface.getOrders(limit, queryFilters, cursor)
-      if (!includeV2) {
-        getOrdersResult.orders = getOrdersResult.orders.filter((order) => order.type !== OrderType.Dutch_V2)
-      }
 
       return {
         statusCode: 200,

lib/handlers/get-orders/injector.ts

@@ -14,7 +14,6 @@ export interface RequestInjected extends ApiRInj {
   limit: number
   queryFilters: GetOrdersQueryParams
   cursor?: string
-  includeV2?: boolean
   orderType?: GetOrderTypeQueryParamEnum
 }