8820206377

Committed 24 Apr 2024 04:34PM UTC coverage: 92.303% (-0.1%) from 92.411%

Build # 8820206377

Build Type

push

github

Committed by

fmrsabino

Commit Message

wip

Run Details

1917 of 2341 branches covered (81.89%)

Branch coverage included in aggregate %.

7 of 9 new or added lines in 1 file covered. (77.78%)

2 existing lines in 2 files now uncovered.

6885 of 7195 relevant lines covered (95.69%)

308.1 hits per line

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

41.67

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

import { Inject, Injectable, Module } from '@nestjs/common';
import { SetPreSignatureDecoder } from '@/domain/swaps/contracts/decoders/set-pre-signature-decoder.helper';
import { SwapOrderTransactionInfo } from '@/routes/transactions/entities/swaps/swap-order-info.entity';
import { TokenInfo } from '@/routes/transactions/entities/swaps/token-info.entity';
import {
  SwapOrderHelper,
  SwapOrderHelperModule,
} from '@/routes/transactions/helpers/swap-order.helper';
import { IConfigurationService } from '@/config/configuration.service.interface';

@Injectable()
export class SwapOrderMapper {
  private readonly restrictApps =
    this.configurationService.getOrThrow('swaps.restrictApps');

  constructor(
    private readonly setPreSignatureDecoder: SetPreSignatureDecoder,
    private readonly swapOrderHelper: SwapOrderHelper,
    @Inject('SWAP_ALLOWED_APPS') private readonly allowedApps: Set<string>,
    @Inject(IConfigurationService)
    private readonly configurationService: IConfigurationService,
  ) {}

  async mapSwapOrder(
    chainId: string,
    transaction: { data: `0x${string}` },
  ): Promise<SwapOrderTransactionInfo> {
    const orderUid: `0x${string}` | null =
      this.setPreSignatureDecoder.getOrderUid(transaction.data);
    if (!orderUid) {
      throw new Error('Order UID not found in transaction data');
    }

    const { order, sellToken, buyToken } = await this.swapOrderHelper.getOrder({
      chainId,
      orderUid,
    });

    if (
      this.restrictApps &&
      !this.allowedApps.has(order.fullAppData['appCode'])
    ) {
      throw new Error(`Unsupported App: ${order.fullAppData['appCode']}`);
    }

    return new SwapOrderTransactionInfo({
      uid: order.uid,
      orderStatus: order.status,
      kind: order.kind,
      class: order.class,
      validUntil: order.validTo,
      sellAmount: order.sellAmount.toString(),
      buyAmount: order.buyAmount.toString(),
      executedSellAmount: order.executedSellAmount.toString(),
      executedBuyAmount: order.executedBuyAmount.toString(),
      sellToken: new TokenInfo({
        address: sellToken.address,
        decimals: sellToken.decimals,
        logoUri: sellToken.logoUri,
        name: sellToken.name,
        symbol: sellToken.symbol,
        trusted: sellToken.trusted,
      }),
      buyToken: new TokenInfo({
        address: buyToken.address,
        decimals: buyToken.decimals,
        logoUri: buyToken.logoUri,
        name: buyToken.name,
        symbol: buyToken.symbol,
        trusted: buyToken.trusted,
      }),
      explorerUrl: this.swapOrderHelper.getOrderExplorerUrl(order),
      executedSurplusFee: order.executedSurplusFee?.toString() ?? null,
      fullAppData: order.fullAppData,
    });
  }
}

function allowedAppsFactory(
  configurationService: IConfigurationService,
): Set<string> {
  const allowedApps =
    configurationService.getOrThrow<string[]>('swaps.allowedApps');
  return new Set(allowedApps);
}

@Module({
  imports: [SwapOrderHelperModule],
  providers: [
    SwapOrderMapper,
    SetPreSignatureDecoder,
    {
      provide: 'SWAP_ALLOWED_APPS',
      useFactory: allowedAppsFactory,
      inject: [IConfigurationService],
    },
  ],
  exports: [SwapOrderMapper],
})
export class SwapOrderMapperModule {}

1	import { Inject, Injectable, Module } from '@nestjs/common';	102✔
2	import { SetPreSignatureDecoder } from '@/domain/swaps/contracts/decoders/set-pre-signature-decoder.helper';	102✔
3	import { SwapOrderTransactionInfo } from '@/routes/transactions/entities/swaps/swap-order-info.entity';	102✔
4	import { TokenInfo } from '@/routes/transactions/entities/swaps/token-info.entity';	102✔
5	import {	102✔
6	SwapOrderHelper,
7	SwapOrderHelperModule,
8	} from '@/routes/transactions/helpers/swap-order.helper';
9	import { IConfigurationService } from '@/config/configuration.service.interface';	102✔
10
11	@Injectable()
12	export class SwapOrderMapper {	102✔
13	private readonly restrictApps =	1,236✔
14	this.configurationService.getOrThrow('swaps.restrictApps');
15
16	constructor(
17	private readonly setPreSignatureDecoder: SetPreSignatureDecoder,	1,236✔
18	private readonly swapOrderHelper: SwapOrderHelper,	1,236✔
19	@Inject('SWAP_ALLOWED_APPS') private readonly allowedApps: Set<string>,	1,236✔
20	@Inject(IConfigurationService)
21	private readonly configurationService: IConfigurationService,	1,236✔
22	) {}
23
24	async mapSwapOrder(
25	chainId: string,
26	transaction: { data: `0x${string}` },
27	): Promise<SwapOrderTransactionInfo> {
28	const orderUid: `0x${string}` \| null =
29	this.setPreSignatureDecoder.getOrderUid(transaction.data);	×
30	if (!orderUid) {	×
31	throw new Error('Order UID not found in transaction data');	×
32	}
33
34	const { order, sellToken, buyToken } = await this.swapOrderHelper.getOrder({	×
35	chainId,
36	orderUid,
37	});
38
NEW 39	if (	×
40	this.restrictApps &&	×
41	!this.allowedApps.has(order.fullAppData['appCode'])
42	) {
NEW 43	throw new Error(`Unsupported App: ${order.fullAppData['appCode']}`);	×
44	}
45
UNCOV 46	return new SwapOrderTransactionInfo({	×
47	uid: order.uid,
48	orderStatus: order.status,
49	kind: order.kind,
50	class: order.class,
51	validUntil: order.validTo,
52	sellAmount: order.sellAmount.toString(),
53	buyAmount: order.buyAmount.toString(),
54	executedSellAmount: order.executedSellAmount.toString(),
55	executedBuyAmount: order.executedBuyAmount.toString(),
56	sellToken: new TokenInfo({
57	address: sellToken.address,
58	decimals: sellToken.decimals,
59	logoUri: sellToken.logoUri,
60	name: sellToken.name,
61	symbol: sellToken.symbol,
62	trusted: sellToken.trusted,
63	}),
64	buyToken: new TokenInfo({
65	address: buyToken.address,
66	decimals: buyToken.decimals,
67	logoUri: buyToken.logoUri,
68	name: buyToken.name,
69	symbol: buyToken.symbol,
70	trusted: buyToken.trusted,
71	}),
72	explorerUrl: this.swapOrderHelper.getOrderExplorerUrl(order),
73	executedSurplusFee: order.executedSurplusFee?.toString() ?? null,	×
74	fullAppData: order.fullAppData,
75	});
76	}
77	}
78
79	function allowedAppsFactory(
80	configurationService: IConfigurationService,
81	): Set<string> {
82	const allowedApps =
83	configurationService.getOrThrow<string[]>('swaps.allowedApps');	1,236✔
84	return new Set(allowedApps);	1,236✔
85	}
86
87	@Module({
88	imports: [SwapOrderHelperModule],
89	providers: [
90	SwapOrderMapper,
91	SetPreSignatureDecoder,
92	{
93	provide: 'SWAP_ALLOWED_APPS',
94	useFactory: allowedAppsFactory,
95	inject: [IConfigurationService],
96	},
97	],
98	exports: [SwapOrderMapper],
99	})
100	export class SwapOrderMapperModule {}	102✔

safe-global / safe-client-gateway / 8820206377

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