9759584343

Committed 02 Jul 2024 10:48AM UTC coverage: 48.567% (-0.03%) from 48.597%

Build # 9759584343

Build Type

push

github

Committed by

web-flow

Commit Message

Add executedSurplusFee to TwapOrders (#1714)

Adds executedSurplusFee to txInfo for TwapOrder items, as the sum of the executedSurplusFee values in the order parts.

Run Details

414 of 2530 branches covered (16.36%)

Branch coverage included in aggregate %.

2 of 7 new or added lines in 3 files covered. (28.57%)

1 existing line in 1 file now uncovered.

4213 of 6997 relevant lines covered (60.21%)

13.13 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

64.41

/src/routes/transactions/entities/swaps/twap-order-info.entity.ts

import {
  OrderStatus,
  OrderKind,
  OrderClass,
} from '@/domain/swaps/entities/order.entity';
import { TokenInfo } from '@/routes/transactions/entities/swaps/token-info.entity';
import {
  TransactionInfo,
  TransactionInfoType,
} from '@/routes/transactions/entities/transaction-info.entity';
import {
  ApiExtraModels,
  ApiProperty,
  ApiPropertyOptional,
} from '@nestjs/swagger';

export enum DurationType {
  Auto = 'AUTO',
  LimitDuration = 'LIMIT_DURATION',
}

export enum StartTimeValue {
  AtMiningTime = 'AT_MINING_TIME',
  AtEpoch = 'AT_EPOCH',
}

export type DurationOfPart =
  | { durationType: DurationType.Auto }
  | { durationType: DurationType.LimitDuration; duration: string };

export type StartTime =
  | { startType: StartTimeValue.AtMiningTime }
  | { startType: StartTimeValue.AtEpoch; epoch: number };

export type TwapOrderInfo = {
  status: OrderStatus;
  kind: OrderKind.Sell;
  class: OrderClass.Limit;
  validUntil: number;
  sellAmount: string;
  buyAmount: string;
  executedSellAmount: string | null;
  executedBuyAmount: string | null;
  executedSurplusFee: string | null;
  sellToken: TokenInfo;
  buyToken: TokenInfo;
  receiver: `0x${string}`;
  owner: `0x${string}`;
  numberOfParts: string;
  partSellAmount: string;
  minPartLimit: string;
  timeBetweenParts: number;
  durationOfPart: DurationOfPart;
  startTime: StartTime;
};

@ApiExtraModels(TokenInfo)
export class TwapOrderTransactionInfo
  extends TransactionInfo
  implements TwapOrderInfo
{
  @ApiProperty({ enum: [TransactionInfoType.TwapOrder] })
  override type = TransactionInfoType.TwapOrder;

  @ApiProperty({
    description: 'The TWAP status',
    enum: OrderStatus,
  })
  status: OrderStatus;

  @ApiProperty({ enum: OrderKind })
  kind: OrderKind.Sell;

  @ApiProperty({ enum: OrderClass })
  class: OrderClass.Limit;

  @ApiProperty({ description: 'The timestamp when the TWAP expires' })
  validUntil: number;

  @ApiProperty({
    description: 'The sell token raw amount (no decimals)',
  })
  sellAmount: string;

  @ApiProperty({
    description: 'The buy token raw amount (no decimals)',
  })
  buyAmount: string;

  @ApiPropertyOptional({
    nullable: true,
    description:
      'The executed sell token raw amount (no decimals), or null if there are too many parts',
  })
  executedSellAmount: string | null;

  @ApiPropertyOptional({
    nullable: true,
    description:
      'The executed buy token raw amount (no decimals), or null if there are too many parts',
  })
  executedBuyAmount: string | null;

  @ApiPropertyOptional({
    nullable: true,
    description:
      'The executed surplus fee raw amount (no decimals), or null if there are too many parts',
  })
  executedSurplusFee: string | null;

  @ApiProperty({ description: 'The sell token of the TWAP' })
  sellToken: TokenInfo;

  @ApiProperty({ description: 'The buy token of the TWAP' })
  buyToken: TokenInfo;

  @ApiProperty({
    description: 'The address to receive the proceeds of the trade',
  })
  receiver: `0x${string}`;

  @ApiProperty({
    type: String,
  })
  owner: `0x${string}`;

  @ApiPropertyOptional({
    type: Object,
    nullable: true,
    description: 'The App Data for this TWAP',
  })
  fullAppData: Record<string, unknown> | null;

  @ApiProperty({
    description: 'The number of parts in the TWAP',
  })
  numberOfParts: string;

  @ApiProperty({
    description: 'The amount of sellToken to sell in each part',
  })
  partSellAmount: string;

  @ApiProperty({
    description: 'The amount of buyToken that must be bought in each part',
  })
  minPartLimit: string;

  @ApiProperty({
    description: 'The duration of the TWAP interval',
  })
  timeBetweenParts: number;

  @ApiProperty({
    description: 'Whether the TWAP is valid for the entire interval or not',
  })
  durationOfPart: DurationOfPart;

  @ApiProperty({
    description: 'The start time of the TWAP',
  })
  startTime: StartTime;

  constructor(args: {
    status: OrderStatus;
    kind: OrderKind.Sell;
    class: OrderClass.Limit;
    validUntil: number;
    sellAmount: string;
    buyAmount: string;
    executedSellAmount: string | null;
    executedBuyAmount: string | null;
    executedSurplusFee: string | null;
    sellToken: TokenInfo;
    buyToken: TokenInfo;
    receiver: `0x${string}`;
    owner: `0x${string}`;
    fullAppData: Record<string, unknown> | null;
    numberOfParts: string;
    partSellAmount: string;
    minPartLimit: string;
    timeBetweenParts: number;
    durationOfPart: DurationOfPart;
    startTime: StartTime;
  }) {
    super(TransactionInfoType.SwapOrder, null, null);
    this.status = args.status;
    this.kind = args.kind;
    this.class = args.class;
    this.validUntil = args.validUntil;
    this.sellAmount = args.sellAmount;
    this.buyAmount = args.buyAmount;
    this.executedSellAmount = args.executedSellAmount;
    this.executedBuyAmount = args.executedBuyAmount;
    this.executedSurplusFee = args.executedSurplusFee;
    this.sellToken = args.sellToken;
    this.buyToken = args.buyToken;
    this.receiver = args.receiver;
    this.owner = args.owner;
    this.fullAppData = args.fullAppData;
    this.numberOfParts = args.numberOfParts;
    this.partSellAmount = args.partSellAmount;
    this.minPartLimit = args.minPartLimit;
    this.timeBetweenParts = args.timeBetweenParts;
    this.durationOfPart = args.durationOfPart;
    this.startTime = args.startTime;
  }
}

1	import {	16✔
2	OrderStatus,
3	OrderKind,
4	OrderClass,
5	} from '@/domain/swaps/entities/order.entity';
6	import { TokenInfo } from '@/routes/transactions/entities/swaps/token-info.entity';	16✔
7	import {	16✔
8	TransactionInfo,
9	TransactionInfoType,
10	} from '@/routes/transactions/entities/transaction-info.entity';
11	import {	16✔
12	ApiExtraModels,
13	ApiProperty,
14	ApiPropertyOptional,
15	} from '@nestjs/swagger';
16
17	export enum DurationType {	16✔
18	Auto = 'AUTO',	16✔
19	LimitDuration = 'LIMIT_DURATION',	16✔
20	}
21
22	export enum StartTimeValue {	16✔
23	AtMiningTime = 'AT_MINING_TIME',	16✔
24	AtEpoch = 'AT_EPOCH',	16✔
25	}
26
27	export type DurationOfPart =
28	\| { durationType: DurationType.Auto }
29	\| { durationType: DurationType.LimitDuration; duration: string };
30
31	export type StartTime =
32	\| { startType: StartTimeValue.AtMiningTime }
33	\| { startType: StartTimeValue.AtEpoch; epoch: number };
34
35	export type TwapOrderInfo = {
36	status: OrderStatus;
37	kind: OrderKind.Sell;
38	class: OrderClass.Limit;
39	validUntil: number;
40	sellAmount: string;
41	buyAmount: string;
42	executedSellAmount: string \| null;
43	executedBuyAmount: string \| null;
44	executedSurplusFee: string \| null;
45	sellToken: TokenInfo;
46	buyToken: TokenInfo;
47	receiver: `0x${string}`;
48	owner: `0x${string}`;
49	numberOfParts: string;
50	partSellAmount: string;
51	minPartLimit: string;
52	timeBetweenParts: number;
53	durationOfPart: DurationOfPart;
54	startTime: StartTime;
55	};
56
57	@ApiExtraModels(TokenInfo)
58	export class TwapOrderTransactionInfo	16✔
59	extends TransactionInfo
60	implements TwapOrderInfo
61	{
62	@ApiProperty({ enum: [TransactionInfoType.TwapOrder] })
63	override type = TransactionInfoType.TwapOrder;	16✔
64
65	@ApiProperty({
66	description: 'The TWAP status',
67	enum: OrderStatus,
68	})
69	status: OrderStatus;	16✔
70
71	@ApiProperty({ enum: OrderKind })
72	kind: OrderKind.Sell;	16✔
73
74	@ApiProperty({ enum: OrderClass })
75	class: OrderClass.Limit;	16✔
76
77	@ApiProperty({ description: 'The timestamp when the TWAP expires' })
78	validUntil: number;	16✔
79
80	@ApiProperty({
81	description: 'The sell token raw amount (no decimals)',
82	})
83	sellAmount: string;	16✔
84
85	@ApiProperty({
86	description: 'The buy token raw amount (no decimals)',
87	})
88	buyAmount: string;	16✔
89
90	@ApiPropertyOptional({
91	nullable: true,
92	description:
93	'The executed sell token raw amount (no decimals), or null if there are too many parts',
94	})
95	executedSellAmount: string \| null;	16✔
96
97	@ApiPropertyOptional({
98	nullable: true,
99	description:
100	'The executed buy token raw amount (no decimals), or null if there are too many parts',
101	})
102	executedBuyAmount: string \| null;	16✔
103
104	@ApiPropertyOptional({
105	nullable: true,
106	description:
107	'The executed surplus fee raw amount (no decimals), or null if there are too many parts',
108	})
109	executedSurplusFee: string \| null;	16✔
110
111	@ApiProperty({ description: 'The sell token of the TWAP' })
112	sellToken: TokenInfo;	16✔
113
114	@ApiProperty({ description: 'The buy token of the TWAP' })
115	buyToken: TokenInfo;	16✔
116
117	@ApiProperty({
118	description: 'The address to receive the proceeds of the trade',
119	})
120	receiver: `0x${string}`;	16✔
121
122	@ApiProperty({
123	type: String,
124	})
125	owner: `0x${string}`;	16✔
126
127	@ApiPropertyOptional({
128	type: Object,
129	nullable: true,
130	description: 'The App Data for this TWAP',
131	})
132	fullAppData: Record<string, unknown> \| null;	16✔
133
134	@ApiProperty({
135	description: 'The number of parts in the TWAP',
136	})
137	numberOfParts: string;	16✔
138
139	@ApiProperty({
140	description: 'The amount of sellToken to sell in each part',
141	})
142	partSellAmount: string;	16✔
143
144	@ApiProperty({
145	description: 'The amount of buyToken that must be bought in each part',
146	})
147	minPartLimit: string;	16✔
148
149	@ApiProperty({
150	description: 'The duration of the TWAP interval',
151	})
152	timeBetweenParts: number;	16✔
153
154	@ApiProperty({
155	description: 'Whether the TWAP is valid for the entire interval or not',
156	})
157	durationOfPart: DurationOfPart;	16✔
158
159	@ApiProperty({
160	description: 'The start time of the TWAP',
161	})
162	startTime: StartTime;	16✔
163
164	constructor(args: {
165	status: OrderStatus;
166	kind: OrderKind.Sell;
167	class: OrderClass.Limit;
168	validUntil: number;
169	sellAmount: string;
170	buyAmount: string;
171	executedSellAmount: string \| null;
172	executedBuyAmount: string \| null;
173	executedSurplusFee: string \| null;
174	sellToken: TokenInfo;
175	buyToken: TokenInfo;
176	receiver: `0x${string}`;
177	owner: `0x${string}`;
178	fullAppData: Record<string, unknown> \| null;
179	numberOfParts: string;
180	partSellAmount: string;
181	minPartLimit: string;
182	timeBetweenParts: number;
183	durationOfPart: DurationOfPart;
184	startTime: StartTime;
185	}) {
186	super(TransactionInfoType.SwapOrder, null, null);	×
187	this.status = args.status;	×
188	this.kind = args.kind;	×
189	this.class = args.class;	×
190	this.validUntil = args.validUntil;	×
191	this.sellAmount = args.sellAmount;	×
192	this.buyAmount = args.buyAmount;	×
193	this.executedSellAmount = args.executedSellAmount;	×
194	this.executedBuyAmount = args.executedBuyAmount;	×
NEW 195	this.executedSurplusFee = args.executedSurplusFee;	×
196	this.sellToken = args.sellToken;	×
197	this.buyToken = args.buyToken;	×
198	this.receiver = args.receiver;	×
199	this.owner = args.owner;	×
200	this.fullAppData = args.fullAppData;	×
201	this.numberOfParts = args.numberOfParts;	×
202	this.partSellAmount = args.partSellAmount;	×
203	this.minPartLimit = args.minPartLimit;	×
204	this.timeBetweenParts = args.timeBetweenParts;	×
205	this.durationOfPart = args.durationOfPart;	×
206	this.startTime = args.startTime;	×
207	}
208	}

safe-global / safe-client-gateway / 9759584343

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous