8389512876

Committed 22 Mar 2024 11:18AM UTC coverage: 93.233% (-0.09%) from 93.322%

Build # 8389512876

Build Type

Pull #1338

github

Committed by

fmrsabino

Commit Message

Add filledPercentage to SwapOrderTransactionInfo

Pull Request Pull Request #1338: Add filledPercentage to SwapOrderTransactionInfo

Run Details

1827 of 2206 branches covered (82.82%)

Branch coverage included in aggregate %.

9 of 10 new or added lines in 2 files covered. (90.0%)

4 existing lines in 1 file now uncovered.

6439 of 6660 relevant lines covered (96.68%)

358.58 hits per line

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

88.54

/src/routes/transactions/mappers/common/swap-order.mapper.ts

import { Inject, Injectable, Module } from '@nestjs/common';
import { MultisigTransaction } from '@/domain/safe/entities/multisig-transaction.entity';
import { ModuleTransaction } from '@/domain/safe/entities/module-transaction.entity';
import { SetPreSignatureDecoder } from '@/domain/swaps/contracts/decoders/set-pre-signature-decoder.helper';
import { isHex } from 'viem';
import {
  DefaultSwapOrderTransactionInfo,
  FulfilledSwapOrderTransactionInfo,
  SwapOrderTransactionInfo,
  TokenInfo,
} from '@/routes/transactions/entities/swap-order-info.entity';
import { ITokenRepository } from '@/domain/tokens/token.repository.interface';
import { CustomTransactionMapper } from '@/routes/transactions/mappers/common/custom-transaction.mapper';
import { CustomTransactionInfo } from '@/routes/transactions/entities/custom-transaction.entity';
import { Token } from '@/domain/tokens/entities/token.entity';
import { SwapsRepository } from '@/domain/swaps/swaps.repository';
import { SwapsModule } from '@/domain/swaps/swaps.module';
import { AddressInfoModule } from '@/routes/common/address-info/address-info.module';
import { Order } from '@/domain/swaps/entities/order.entity';
import { ILoggingService, LoggingService } from '@/logging/logging.interface';

/**
 * Represents the amount of a token in a swap order.
 */
class TokenAmount {
  readonly token: Token & {
    decimals: number;
  };
  private readonly amount: bigint;
  private readonly executedAmount: bigint;

  constructor(args: { token: Token; amount: bigint; executedAmount: bigint }) {
    if (args.token.decimals === null)
      throw new Error(`Token ${args.token.address} has no decimals set.`);

    this.token = { ...args.token, decimals: args.token.decimals };
    this.amount = args.amount;
    this.executedAmount = args.executedAmount;
  }

  getAmount(): number {
    return asDecimal(this.amount, this.token.decimals);
  }

  getExecutedAmount(): number {
    return asDecimal(this.executedAmount, this.token.decimals);
  }

  toTokenInfo(): TokenInfo {
    return new TokenInfo({
      amount: this.getAmount().toString(),
      symbol: this.token.symbol,
      logo: this.token.logoUri,
    });
  }
}

function asDecimal(amount: number | bigint, decimals: number): number {
  return Number(amount) / 10 ** decimals;
}

@Injectable()
export class SwapOrderMapper {
  constructor(
    private readonly swapsRepository: SwapsRepository,
    private readonly setPreSignatureDecoder: SetPreSignatureDecoder,
    @Inject(ITokenRepository)
    private readonly tokenRepository: ITokenRepository,
    private readonly customTransactionMapper: CustomTransactionMapper,
    @Inject(LoggingService) private readonly loggingService: ILoggingService,
  ) {}

  async mapSwapOrder(
    chainId: string,
    transaction: MultisigTransaction | ModuleTransaction,
    dataSize: number,
  ): Promise<SwapOrderTransactionInfo | CustomTransactionInfo> {
    if (!isHex(transaction.data)) {
      return this._mapUnknownOrderStatus(chainId, transaction, dataSize);
    }

    const orderUid: `0x${string}` | null =
      this.setPreSignatureDecoder.getOrderUid(transaction.data);
    if (!orderUid) {
      return this._mapUnknownOrderStatus(chainId, transaction, dataSize);
    }

    try {
      const order = await this.swapsRepository.getOrder(chainId, orderUid);
      const [buyToken, sellToken] = await Promise.all([
        this.tokenRepository.getToken({
          chainId,
          address: order.buyToken,
        }),
        this.tokenRepository.getToken({
          chainId,
          address: order.sellToken,
        }),
      ]);

      const buyTokenAmount = new TokenAmount({
        token: buyToken,
        amount: order.buyAmount,
        executedAmount: order.executedBuyAmount,
      });
      const sellTokenAmount = new TokenAmount({
        token: sellToken,
        amount: order.sellAmount,
        executedAmount: order.executedSellAmount,
      });

      switch (order.status) {
        case 'fulfilled':
          return this._mapFulfilledOrderStatus({
            buyToken: buyTokenAmount,
            sellToken: sellTokenAmount,
            order,
          });
        case 'open':
        case 'cancelled':
        case 'expired':
          return this._mapDefaultOrderStatus({
            buyToken: buyTokenAmount,
            sellToken: sellTokenAmount,
            order,
          });
        default:
          return this._mapUnknownOrderStatus(chainId, transaction, dataSize);
      }
    } catch (e) {
      this.loggingService.warn(e);
      return this.customTransactionMapper.mapCustomTransaction(
        transaction,
        dataSize,
        chainId,
        null,
        null,
      );
    }
  }

  private _mapUnknownOrderStatus(
    chainId: string,
    transaction: MultisigTransaction | ModuleTransaction,
    dataSize: number,
  ): Promise<CustomTransactionInfo> {
    return this.customTransactionMapper.mapCustomTransaction(
      transaction,
      dataSize,
      chainId,
      null,
      null,
    );
  }

  private _getExecutionPriceLabel(
    sellToken: TokenAmount,
    buyToken: TokenAmount,
  ): string {
    const ratio = sellToken.getExecutedAmount() / buyToken.getExecutedAmount();
    return `1 ${sellToken.token.symbol} = ${ratio} ${buyToken.token.symbol}`;
  }

  private _getLimitPriceLabel(
    sellToken: TokenAmount,
    buyToken: TokenAmount,
  ): string {
    const ratio = sellToken.getAmount() / buyToken.getAmount();
    return `1 ${sellToken.token.symbol} = ${ratio} ${buyToken.token.symbol}`;
  }

  /**
   * Returns the filled percentage of an order.
   * The percentage is calculated as the ratio of the executed amount to the total amount.
   *
   * @param order - The order to calculate the filled percentage for.
   * @private
   */
  private _getFilledPercentage(order: Order): string {
    let executed: number;
    let total: number;
    if (order.kind === 'buy') {
      executed = Number(order.executedBuyAmount);
      total = Number(order.buyAmount);
    } else if (order.kind === 'sell') {
      executed = Number(order.executedSellAmount);
      total = Number(order.sellAmount);
    } else {
      throw new Error('Unknown order kind');
    }

    return ((executed / total) * 100).toFixed(2).toString();
  }

  private _mapFulfilledOrderStatus(args: {
    buyToken: TokenAmount;
    sellToken: TokenAmount;
    order: Order;
  }): SwapOrderTransactionInfo {
    if (args.order.kind === 'unknown') {
      throw new Error('Unknown order kind');
    }
    const surplusFeeLabel: string | null = args.order.executedSurplusFee
      ? this._getExecutedSurplusFeeLabel(
          args.order.executedSurplusFee,
          args.buyToken.token,
        )
      : null;

    return new FulfilledSwapOrderTransactionInfo({
      orderKind: args.order.kind,
      sellToken: args.sellToken.toTokenInfo(),
      buyToken: args.buyToken.toTokenInfo(),
      expiresTimestamp: args.order.validTo,
      surplusFeeLabel: surplusFeeLabel,
      executionPriceLabel: this._getExecutionPriceLabel(
        args.sellToken,
        args.buyToken,
      ),
      filledPercentage: this._getFilledPercentage(args.order),
    });
  }

  private _getExecutedSurplusFeeLabel(
    executedSurplusFee: bigint,
    token: Token & { decimals: number },
  ): string {
    const surplus = asDecimal(executedSurplusFee, token.decimals);
    return `${surplus} ${token.symbol}`;
  }

  private _mapDefaultOrderStatus(args: {
    buyToken: TokenAmount;
    sellToken: TokenAmount;
    order: Order;
  }): SwapOrderTransactionInfo {
    if (args.order.kind === 'unknown') {
      throw new Error('Unknown order kind');
    }
    if (
      args.order.status === 'fulfilled' ||
      args.order.status === 'presignaturePending' ||
      args.order.status === 'unknown'
    )
      throw new Error(
        `${args.order.status} orders should not be mapped as default orders. Order UID = ${args.order.uid}`,
      );
    return new DefaultSwapOrderTransactionInfo({
      status: args.order.status,
      orderKind: args.order.kind,
      sellToken: args.sellToken.toTokenInfo(),
      buyToken: args.buyToken.toTokenInfo(),
      expiresTimestamp: args.order.validTo,
      limitPriceLabel: this._getLimitPriceLabel(args.sellToken, args.buyToken),
      filledPercentage: this._getFilledPercentage(args.order),
    });
  }
}

@Module({
  // TODO AddressInfoModule is not needed in this module but it is required by the CustomTransactionMapper.
  //  The CustomTransactionMapper (module to be created) should be the one providing it instead.
  imports: [SwapsModule, AddressInfoModule],
  providers: [SwapOrderMapper, SetPreSignatureDecoder, CustomTransactionMapper],
  exports: [SwapOrderMapper],
})
export class SwapOrderMapperModule {}

1	import { Inject, Injectable, Module } from '@nestjs/common';	98✔
2	import { MultisigTransaction } from '@/domain/safe/entities/multisig-transaction.entity';
3	import { ModuleTransaction } from '@/domain/safe/entities/module-transaction.entity';
4	import { SetPreSignatureDecoder } from '@/domain/swaps/contracts/decoders/set-pre-signature-decoder.helper';	98✔
5	import { isHex } from 'viem';	98✔
6	import {	98✔
7	DefaultSwapOrderTransactionInfo,
8	FulfilledSwapOrderTransactionInfo,
9	SwapOrderTransactionInfo,
10	TokenInfo,
11	} from '@/routes/transactions/entities/swap-order-info.entity';
12	import { ITokenRepository } from '@/domain/tokens/token.repository.interface';	98✔
13	import { CustomTransactionMapper } from '@/routes/transactions/mappers/common/custom-transaction.mapper';	98✔
14	import { CustomTransactionInfo } from '@/routes/transactions/entities/custom-transaction.entity';
15	import { Token } from '@/domain/tokens/entities/token.entity';
16	import { SwapsRepository } from '@/domain/swaps/swaps.repository';	98✔
17	import { SwapsModule } from '@/domain/swaps/swaps.module';	98✔
18	import { AddressInfoModule } from '@/routes/common/address-info/address-info.module';	98✔
19	import { Order } from '@/domain/swaps/entities/order.entity';
20	import { ILoggingService, LoggingService } from '@/logging/logging.interface';	98✔
21
22	/**
23	* Represents the amount of a token in a swap order.
24	*/
25	class TokenAmount {
26	readonly token: Token & {
27	decimals: number;
28	};
29	private readonly amount: bigint;
30	private readonly executedAmount: bigint;
31
32	constructor(args: { token: Token; amount: bigint; executedAmount: bigint }) {
33	if (args.token.decimals === null)	48!
34	throw new Error(`Token ${args.token.address} has no decimals set.`);	×
35
36	this.token = { ...args.token, decimals: args.token.decimals };	48✔
37	this.amount = args.amount;	48✔
38	this.executedAmount = args.executedAmount;	48✔
39	}
40
41	getAmount(): number {
42	return asDecimal(this.amount, this.token.decimals);	60✔
43	}
44
45	getExecutedAmount(): number {
46	return asDecimal(this.executedAmount, this.token.decimals);	4✔
47	}
48
49	toTokenInfo(): TokenInfo {
50	return new TokenInfo({	32✔
51	amount: this.getAmount().toString(),
52	symbol: this.token.symbol,
53	logo: this.token.logoUri,
54	});
55	}
56	}
57
58	function asDecimal(amount: number \| bigint, decimals: number): number {
59	return Number(amount) / 10 ** decimals;	66✔
60	}
61
62	@Injectable()
63	export class SwapOrderMapper {	98✔
64	constructor(
65	private readonly swapsRepository: SwapsRepository,	1,220✔
66	private readonly setPreSignatureDecoder: SetPreSignatureDecoder,	1,220✔
67	@Inject(ITokenRepository)
68	private readonly tokenRepository: ITokenRepository,	1,220✔
69	private readonly customTransactionMapper: CustomTransactionMapper,	1,220✔
70	@Inject(LoggingService) private readonly loggingService: ILoggingService,	1,220✔
71	) {}
72
73	async mapSwapOrder(
74	chainId: string,
75	transaction: MultisigTransaction \| ModuleTransaction,
76	dataSize: number,
77	): Promise<SwapOrderTransactionInfo \| CustomTransactionInfo> {
78	if (!isHex(transaction.data)) {	32✔
79	return this._mapUnknownOrderStatus(chainId, transaction, dataSize);	2✔
80	}
81
82	const orderUid: `0x${string}` \| null =
83	this.setPreSignatureDecoder.getOrderUid(transaction.data);	30✔
84	if (!orderUid) {	30✔
85	return this._mapUnknownOrderStatus(chainId, transaction, dataSize);	2✔
86	}
87
88	try {	28✔
89	const order = await this.swapsRepository.getOrder(chainId, orderUid);	28✔
90	const [buyToken, sellToken] = await Promise.all([	26✔
91	this.tokenRepository.getToken({
92	chainId,
93	address: order.buyToken,
94	}),
95	this.tokenRepository.getToken({
96	chainId,
97	address: order.sellToken,
98	}),
99	]);
100
101	const buyTokenAmount = new TokenAmount({	24✔
102	token: buyToken,
103	amount: order.buyAmount,
104	executedAmount: order.executedBuyAmount,
105	});
106	const sellTokenAmount = new TokenAmount({	24✔
107	token: sellToken,
108	amount: order.sellAmount,
109	executedAmount: order.executedSellAmount,
110	});
111
112	switch (order.status) {	24!
113	case 'fulfilled':
114	return this._mapFulfilledOrderStatus({	4✔
115	buyToken: buyTokenAmount,
116	sellToken: sellTokenAmount,
117	order,
118	});
119	case 'open':
120	case 'cancelled':
121	case 'expired':
122	return this._mapDefaultOrderStatus({	20✔
123	buyToken: buyTokenAmount,
124	sellToken: sellTokenAmount,
125	order,
126	});
127	default:
128	return this._mapUnknownOrderStatus(chainId, transaction, dataSize);	×
129	}
130	} catch (e) {
131	this.loggingService.warn(e);	12✔
132	return this.customTransactionMapper.mapCustomTransaction(	12✔
133	transaction,
134	dataSize,
135	chainId,
136	null,
137	null,
138	);
139	}
140	}
141
142	private _mapUnknownOrderStatus(
143	chainId: string,
144	transaction: MultisigTransaction \| ModuleTransaction,
145	dataSize: number,
146	): Promise<CustomTransactionInfo> {
147	return this.customTransactionMapper.mapCustomTransaction(	4✔
148	transaction,
149	dataSize,
150	chainId,
151	null,
152	null,
153	);
154	}
155
156	private _getExecutionPriceLabel(
157	sellToken: TokenAmount,
158	buyToken: TokenAmount,
159	): string {
160	const ratio = sellToken.getExecutedAmount() / buyToken.getExecutedAmount();	2✔
161	return `1 ${sellToken.token.symbol} = ${ratio} ${buyToken.token.symbol}`;	2✔
162	}
163
164	private _getLimitPriceLabel(
165	sellToken: TokenAmount,
166	buyToken: TokenAmount,
167	): string {
168	const ratio = sellToken.getAmount() / buyToken.getAmount();	14✔
169	return `1 ${sellToken.token.symbol} = ${ratio} ${buyToken.token.symbol}`;	14✔
170	}
171
172	/**
173	* Returns the filled percentage of an order.
174	* The percentage is calculated as the ratio of the executed amount to the total amount.
175	*
176	* @param order - The order to calculate the filled percentage for.
177	* @private
178	*/
179	private _getFilledPercentage(order: Order): string {
180	let executed: number;
181	let total: number;
182	if (order.kind === 'buy') {	16✔
183	executed = Number(order.executedBuyAmount);	8✔
184	total = Number(order.buyAmount);	8✔
185	} else if (order.kind === 'sell') {	8!
186	executed = Number(order.executedSellAmount);	8✔
187	total = Number(order.sellAmount);	8✔
188	} else {
NEW 189	throw new Error('Unknown order kind');	×
190	}
191
192	return ((executed / total) * 100).toFixed(2).toString();	16✔
193	}
194
195	private _mapFulfilledOrderStatus(args: {
196	buyToken: TokenAmount;
197	sellToken: TokenAmount;
198	order: Order;
199	}): SwapOrderTransactionInfo {
200	if (args.order.kind === 'unknown') {	4✔
201	throw new Error('Unknown order kind');	2✔
202	}
203	const surplusFeeLabel: string \| null = args.order.executedSurplusFee	2!
204	? this._getExecutedSurplusFeeLabel(
205	args.order.executedSurplusFee,
206	args.buyToken.token,
207	)
208	: null;
209
210	return new FulfilledSwapOrderTransactionInfo({	2✔
211	orderKind: args.order.kind,
212	sellToken: args.sellToken.toTokenInfo(),
213	buyToken: args.buyToken.toTokenInfo(),
214	expiresTimestamp: args.order.validTo,
215	surplusFeeLabel: surplusFeeLabel,
216	executionPriceLabel: this._getExecutionPriceLabel(
217	args.sellToken,
218	args.buyToken,
219	),
220	filledPercentage: this._getFilledPercentage(args.order),
221	});
222	}
223
224	private _getExecutedSurplusFeeLabel(
225	executedSurplusFee: bigint,
226	token: Token & { decimals: number },
227	): string {
228	const surplus = asDecimal(executedSurplusFee, token.decimals);	2✔
229	return `${surplus} ${token.symbol}`;	2✔
230	}
231
232	private _mapDefaultOrderStatus(args: {
233	buyToken: TokenAmount;
234	sellToken: TokenAmount;
235	order: Order;
236	}): SwapOrderTransactionInfo {
237	if (args.order.kind === 'unknown') {	20✔
238	throw new Error('Unknown order kind');	6✔
239	}
240	if (	14!
241	args.order.status === 'fulfilled' \|\|	21✔
242	args.order.status === 'presignaturePending' \|\|
243	args.order.status === 'unknown'
244	)
245	throw new Error(	×
246	`${args.order.status} orders should not be mapped as default orders. Order UID = ${args.order.uid}`,
247	);
248	return new DefaultSwapOrderTransactionInfo({	14✔
249	status: args.order.status,
250	orderKind: args.order.kind,
251	sellToken: args.sellToken.toTokenInfo(),
252	buyToken: args.buyToken.toTokenInfo(),
253	expiresTimestamp: args.order.validTo,
254	limitPriceLabel: this._getLimitPriceLabel(args.sellToken, args.buyToken),
255	filledPercentage: this._getFilledPercentage(args.order),
256	});
257	}
258	}
259
260	@Module({
261	// TODO AddressInfoModule is not needed in this module but it is required by the CustomTransactionMapper.
262	// The CustomTransactionMapper (module to be created) should be the one providing it instead.
263	imports: [SwapsModule, AddressInfoModule],
264	providers: [SwapOrderMapper, SetPreSignatureDecoder, CustomTransactionMapper],
265	exports: [SwapOrderMapper],
266	})
267	export class SwapOrderMapperModule {}	98✔

safe-global / safe-client-gateway / 8389512876

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