8846304901

Committed 26 Apr 2024 09:41AM UTC coverage: 91.871% (-0.02%) from 91.894%

Build # 8846304901

Build Type

push

github

Committed by

web-flow

Commit Message

Allow Swap App restriction (#1458)

Adds the ability to restrict the decoding functionality to specific Swap applications. Swap applications can be identified with Metadata that is added to each order by the respective apps. The property which contains this metadata is `fullAppData` – https://explorer.cow.fi/appdata?tab=encode

Changes:

- Two configuration properties were added:
  * `SWAPS_RESTRICT_APPS` – this configuration controls if the App restriction should be enabled or disabled.
  * `SWAPS_ALLOWED_APPS` – this configuration contains the comma separated collection of Swap apps which are allowed to be decoded. This configuration only has an effect if `SWAPS_RESTRICT_APPS` is set to `true`.

Run Details

1926 of 2362 branches covered (81.54%)

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.

6889 of 7233 relevant lines covered (95.24%)

306.48 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,
      receiver: order.receiver,
      owner: order.owner,
      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	receiver: order.receiver,
75	owner: order.owner,
76	fullAppData: order.fullAppData,
77	});
78	}
79	}
80
81	function allowedAppsFactory(
82	configurationService: IConfigurationService,
83	): Set<string> {
84	const allowedApps =
85	configurationService.getOrThrow<string[]>('swaps.allowedApps');	1,236✔
86	return new Set(allowedApps);	1,236✔
87	}
88
89	@Module({
90	imports: [SwapOrderHelperModule],
91	providers: [
92	SwapOrderMapper,
93	SetPreSignatureDecoder,
94	{
95	provide: 'SWAP_ALLOWED_APPS',
96	useFactory: allowedAppsFactory,
97	inject: [IConfigurationService],
98	},
99	],
100	exports: [SwapOrderMapper],
101	})
102	export class SwapOrderMapperModule {}	102✔

safe-global / safe-client-gateway / 8846304901

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