4946384134

Committed 11 May 2023 09:42AM UTC coverage: 90.415%. Remained the same

Build Type

push

github

Committed by Hector Gómez Varela

Commit Message

Fix bad POST payload

Run Details

745 of 878 branches covered (84.85%)

Branch coverage included in aggregate %.

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

1 existing line in 1 file now uncovered.

3792 of 4140 relevant lines covered (91.59%)

39.43 hits per line

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

90.6

/src/datasources/transaction-api/transaction-api.service.ts

import { Backbone } from '../../domain/backbone/entities/backbone.entity';
import { Balance } from '../../domain/balances/entities/balance.entity';
import { MasterCopy } from '../../domain/chains/entities/master-copies.entity';
import { Collectible } from '../../domain/collectibles/entities/collectible.entity';
import { Contract } from '../../domain/contracts/entities/contract.entity';
import { DataDecoded } from '../../domain/data-decoder/entities/data-decoded.entity';
import { Delegate } from '../../domain/delegate/entities/delegate.entity';
import { Page } from '../../domain/entities/page.entity';
import { Estimation } from '../../domain/estimations/entities/estimation.entity';
import { GetEstimationDto } from '../../domain/estimations/entities/get-estimation.dto.entity';
import { ITransactionApi } from '../../domain/interfaces/transaction-api.interface';
import { Message } from '../../domain/messages/entities/message.entity';
import { Device } from '../../domain/notifications/entities/device.entity';
import { CreationTransaction } from '../../domain/safe/entities/creation-transaction.entity';
import { ModuleTransaction } from '../../domain/safe/entities/module-transaction.entity';
import { MultisigTransaction } from '../../domain/safe/entities/multisig-transaction.entity';
import { SafeList } from '../../domain/safe/entities/safe-list.entity';
import { Safe } from '../../domain/safe/entities/safe.entity';
import { Transaction } from '../../domain/safe/entities/transaction.entity';
import { Transfer } from '../../domain/safe/entities/transfer.entity';
import { Token } from '../../domain/tokens/entities/token.entity';
import { ProposeTransactionDto } from '../../domain/transactions/entities/propose-transaction.dto.entity';
import { CacheFirstDataSource } from '../cache/cache.first.data.source';
import { CacheRouter } from '../cache/cache.router';
import { ICacheService } from '../cache/cache.service.interface';
import { HttpErrorFactory } from '../errors/http-error-factory';
import { INetworkService } from '../network/network.service.interface';

export class TransactionApi implements ITransactionApi {
  constructor(
    private readonly chainId: string,
    private readonly baseUrl: string,
    private readonly dataSource: CacheFirstDataSource,
    private readonly cacheService: ICacheService,
    private readonly httpErrorFactory: HttpErrorFactory,
    private readonly networkService: INetworkService,
  ) {}

  async getBalances(
    safeAddress: string,
    trusted?: boolean,
    excludeSpam?: boolean,
  ): Promise<Balance[]> {
    try {
      const cacheDir = CacheRouter.getBalanceCacheDir(
        this.chainId,
        safeAddress,
        trusted,
        excludeSpam,
      );
      const url = `${this.baseUrl}/api/v1/safes/${safeAddress}/balances/usd/`;
      return await this.dataSource.get(cacheDir, url, {
        params: {
          trusted: trusted,
          exclude_spam: excludeSpam,
        },
      });
    } catch (error) {
      throw this.httpErrorFactory.from(error);
    }
  }

  async clearLocalBalances(safeAddress: string): Promise<void> {
    const cacheKey = CacheRouter.getBalancesCacheKey(this.chainId, safeAddress);
    await this.cacheService.deleteByKey(cacheKey);
  }

  async getDataDecoded(data: string, to: string): Promise<DataDecoded> {
    try {
      const url = `${this.baseUrl}/api/v1/data-decoder/`;
      const { data: dataDecoded } = await this.networkService.post(url, {
        data,
        to,
      });
      return dataDecoded;
    } catch (error) {
      throw this.httpErrorFactory.from(error);
    }
  }

  async getCollectibles(
    safeAddress: string,
    limit?: number,
    offset?: number,
    trusted?: boolean,
    excludeSpam?: boolean,
  ): Promise<Page<Collectible>> {
    try {
      const cacheDir = CacheRouter.getCollectiblesCacheDir(
        this.chainId,
        safeAddress,
        limit,
        offset,
        trusted,
        excludeSpam,
      );
      const url = `${this.baseUrl}/api/v2/safes/${safeAddress}/collectibles/`;
      return await this.dataSource.get(cacheDir, url, {
        params: {
          limit: limit,
          offset: offset,
          trusted: trusted,
          exclude_spam: excludeSpam,
        },
      });
    } catch (error) {
      throw this.httpErrorFactory.from(error);
    }
  }

  async getBackbone(): Promise<Backbone> {
    try {
      const cacheDir = CacheRouter.getBackboneCacheDir(this.chainId);
      const url = `${this.baseUrl}/api/v1/about`;
      return await this.dataSource.get(cacheDir, url);
    } catch (error) {
      throw this.httpErrorFactory.from(error);
    }
  }

  async getMasterCopies(): Promise<MasterCopy[]> {
    try {
      const cacheDir = CacheRouter.getMasterCopiesCacheDir(this.chainId);
      const url = `${this.baseUrl}/api/v1/about/master-copies/`;
      return await this.dataSource.get(cacheDir, url);
    } catch (error) {
      throw this.httpErrorFactory.from(error);
    }
  }

  async getSafe(safeAddress: string): Promise<Safe> {
    try {
      const cacheDir = CacheRouter.getSafeCacheDir(this.chainId, safeAddress);
      const url = `${this.baseUrl}/api/v1/safes/${safeAddress}`;
      return await this.dataSource.get(cacheDir, url);
    } catch (error) {
      throw this.httpErrorFactory.from(error);
    }
  }

  async getContract(contractAddress: string): Promise<Contract> {
    try {
      const cacheDir = CacheRouter.getContractCacheDir(
        this.chainId,
        contractAddress,
      );
      const url = `${this.baseUrl}/api/v1/contracts/${contractAddress}`;
      return await this.dataSource.get(cacheDir, url);
    } catch (error) {
      throw this.httpErrorFactory.from(error);
    }
  }

  async getDelegates(
    safeAddress?: string,
    delegate?: string,
    delegator?: string,
    label?: string,
    limit?: number,
    offset?: number,
  ): Promise<Page<Delegate>> {
    try {
      const cacheDir = CacheRouter.getDelegatesCacheDir(
        this.chainId,
        safeAddress,
        delegate,
        delegator,
        label,
        limit,
        offset,
      );
      const url = `${this.baseUrl}/api/v1/delegates/`;
      return await this.dataSource.get(cacheDir, url, {
        params: {
          safe: safeAddress,
          delegate: delegate,
          delegator: delegator,
          label: label,
          limit: limit,
          offset: offset,
        },
      });
    } catch (error) {
      throw this.httpErrorFactory.from(error);
    }
  }

  async postDelegate(
    safeAddress?: string,
    delegate?: string,
    delegator?: string,
    signature?: string,
    label?: string,
  ): Promise<unknown> {
    try {
      const url = `${this.baseUrl}/api/v1/delegates/`;
      return await this.networkService.post(url, {
        safe: safeAddress,
        delegate: delegate,
        delegator: delegator,
        signature: signature,
        label: label,
      });
    } catch (error) {
      throw this.httpErrorFactory.from(error);
    }
  }

  async deleteDelegate(
    delegate: string,
    delegator: string,
    signature: string,
  ): Promise<unknown> {
    try {
      const url = `${this.baseUrl}/api/v1/delegates/${delegate}`;
      return await this.networkService.delete(url, {
        delegate: delegate,
        delegator: delegator,
        signature: signature,
      });
    } catch (error) {
      throw this.httpErrorFactory.from(error);
    }
  }

  async deleteSafeDelegate(
    delegate: string,
    safeAddress: string,
    signature: string,
  ): Promise<void> {
    try {
      const url = `${this.baseUrl}/api/v1/safes/${safeAddress}/delegates/${delegate}`;
      return await this.networkService.delete(url, {
        delegate: delegate,
        safe: safeAddress,
        signature: signature,
      });
    } catch (error) {
      throw this.httpErrorFactory.from(error);
    }
  }

  async getTransfers(
    safeAddress: string,
    onlyErc20: boolean,
    onlyErc721: boolean,
    limit?: number,
    offset?: number,
  ): Promise<Page<Transfer>> {
    try {
      const cacheDir = CacheRouter.getTransfersCacheDir(
        this.chainId,
        safeAddress,
        onlyErc20,
        onlyErc721,
        limit,
        offset,
      );
      const url = `${this.baseUrl}/api/v1/safes/${safeAddress}/transfers/`;
      return await this.dataSource.get(cacheDir, url, {
        params: {
          erc20: onlyErc20,
          erc721: onlyErc721,
          limit: limit,
          offset: offset,
        },
      });
    } catch (error) {
      throw this.httpErrorFactory.from(error);
    }
  }

  async getIncomingTransfers(
    safeAddress: string,
    executionDateGte?: string,
    executionDateLte?: string,
    to?: string,
    value?: string,
    tokenAddress?: string,
    limit?: number,
    offset?: number,
  ): Promise<Page<Transfer>> {
    try {
      const cacheDir = CacheRouter.getIncomingTransfersCacheDir(
        this.chainId,
        safeAddress,
        executionDateGte,
        executionDateLte,
        to,
        value,
        tokenAddress,
        limit,
        offset,
      );
      const url = `${this.baseUrl}/api/v1/safes/${safeAddress}/incoming-transfers/`;
      return await this.dataSource.get(cacheDir, url, {
        params: {
          execution_date__gte: executionDateGte,
          execution_date__lte: executionDateLte,
          to,
          value,
          tokenAddress,
          limit,
          offset,
        },
      });
    } catch (error) {
      throw this.httpErrorFactory.from(error);
    }
  }

  async getModuleTransactions(
    safeAddress: string,
    to?: string,
    module?: string,
    limit?: number,
    offset?: number,
  ): Promise<Page<ModuleTransaction>> {
    try {
      const cacheDir = CacheRouter.getModuleTransactionsCacheDir(
        this.chainId,
        safeAddress,
        to,
        module,
        limit,
        offset,
      );
      const url = `${this.baseUrl}/api/v1/safes/${safeAddress}/module-transactions/`;
      return await this.dataSource.get(cacheDir, url, {
        params: {
          to,
          module,
          limit,
          offset,
        },
      });
    } catch (error) {
      throw this.httpErrorFactory.from(error);
    }
  }

  async getMultisigTransactions(
    safeAddress: string,
    ordering?: string,
    executed?: boolean,
    trusted?: boolean,
    executionDateGte?: string,
    executionDateLte?: string,
    to?: string,
    value?: string,
    nonce?: string,
    limit?: number,
    offset?: number,
  ): Promise<Page<MultisigTransaction>> {
    try {
      const cacheDir = CacheRouter.getMultisigTransactionsCacheDir(
        this.chainId,
        safeAddress,
        ordering,
        executed,
        trusted,
        executionDateGte,
        executionDateLte,
        to,
        value,
        nonce,
        limit,
        offset,
      );
      const url = `${this.baseUrl}/api/v1/safes/${safeAddress}/multisig-transactions/`;
      return await this.dataSource.get(cacheDir, url, {
        params: {
          safe: safeAddress,
          ordering,
          executed,
          trusted,
          execution_date__gte: executionDateGte,
          execution_date__lte: executionDateLte,
          to,
          value,
          nonce,
          limit,
          offset,
        },
      });
    } catch (error) {
      throw this.httpErrorFactory.from(error);
    }
  }

  async getMultisigTransaction(
    safeTransactionHash: string,
  ): Promise<MultisigTransaction> {
    try {
      const cacheDir = CacheRouter.getMultisigTransactionsCacheDir(
        this.chainId,
        safeTransactionHash,
      );
      const url = `${this.baseUrl}/api/v1/multisig-transactions/${safeTransactionHash}/`;
      return await this.dataSource.get(cacheDir, url);
    } catch (error) {
      throw this.httpErrorFactory.from(error);
    }
  }

  async getCreationTransaction(
    safeAddress: string,
  ): Promise<CreationTransaction> {
    try {
      const cacheDir = CacheRouter.getCreationTransactionCacheDir(
        this.chainId,
        safeAddress,
      );
      const url = `${this.baseUrl}/api/v1/safes/${safeAddress}/creation/`;
      return await this.dataSource.get(cacheDir, url);
    } catch (error) {
      throw this.httpErrorFactory.from(error);
    }
  }

  async getAllTransactions(
    safeAddress: string,
    ordering?: string,
    executed?: boolean,
    queued?: boolean,
    limit?: number,
    offset?: number,
  ): Promise<Page<Transaction>> {
    try {
      const cacheDir = CacheRouter.getAllTransactionsCacheDir(
        this.chainId,
        safeAddress,
        ordering,
        executed,
        queued,
        limit,
        offset,
      );
      const url = `${this.baseUrl}/api/v1/safes/${safeAddress}/all-transactions/`;
      return await this.dataSource.get(cacheDir, url, {
        params: {
          safe: safeAddress,
          ordering: ordering,
          executed: executed,
          queued: queued,
          limit: limit,
          offset: offset,
        },
      });
    } catch (error) {
      throw this.httpErrorFactory.from(error);
    }
  }

  async getToken(address: string): Promise<Token> {
    try {
      const cacheDir = CacheRouter.getTokenCacheDir(this.chainId, address);
      const url = `${this.baseUrl}/api/v1/tokens/${address}`;
      return await this.dataSource.get(cacheDir, url);
    } catch (error) {
      throw this.httpErrorFactory.from(error);
    }
  }

  async getTokens(limit?: number, offset?: number): Promise<Page<Token>> {
    try {
      const cacheDir = CacheRouter.getTokensCacheDir(
        this.chainId,
        limit,
        offset,
      );
      const url = `${this.baseUrl}/api/v1/tokens/`;
      return await this.dataSource.get(cacheDir, url, {
        params: {
          limit: limit,
          offset: offset,
        },
      });
    } catch (error) {
      throw this.httpErrorFactory.from(error);
    }
  }

  async getSafesByOwner(ownerAddress: string): Promise<SafeList> {
    try {
      const cacheDir = CacheRouter.getSafesByOwnerCacheDir(
        this.chainId,
        ownerAddress,
      );
      const url = `${this.baseUrl}/api/v1/owners/${ownerAddress}/safes/`;
      return await this.dataSource.get(cacheDir, url);
    } catch (error) {
      throw this.httpErrorFactory.from(error);
    }
  }

  async postDeviceRegistration(
    device: Device,
    safes: string[],
    signatures: string[],
  ): Promise<void> {
    try {
      const url = `${this.baseUrl}/api/v1/notifications/devices/`;
      await this.networkService.post(url, {
        uuid: device.uuid,
        cloudMessagingToken: device.cloudMessagingToken,
        buildNumber: device.buildNumber,
        bundle: device.bundle,
        deviceType: device.deviceType,
        version: device.version,
        timestamp: device.timestamp,
        safes,
        signatures,
      });
    } catch (error) {
      throw this.httpErrorFactory.from(error);
    }
  }

  async deleteDeviceRegistration(
    uuid: string,
    safeAddress: string,
  ): Promise<void> {
    try {
      const url = `${this.baseUrl}/api/v1/notifications/devices/${uuid}/safes/${safeAddress}`;
      await this.networkService.delete(url);
    } catch (error) {
      throw this.httpErrorFactory.from(error);
    }
  }

  async getEstimation(
    address: string,
    getEstimationDto: GetEstimationDto,
  ): Promise<Estimation> {
    try {
      const url = `${this.baseUrl}/api/v1/safes/${address}/multisig-transactions/estimations/`;
      const { data: estimation } = await this.networkService.post(url, {
        to: getEstimationDto.to,
        value: getEstimationDto.value,
        data: getEstimationDto.data,
        operation: getEstimationDto.operation,
      });
      return estimation;
    } catch (error) {
      throw this.httpErrorFactory.from(error);
    }
  }

  async getMessageByHash(messageHash: string): Promise<Message> {
    try {
      const url = `${this.baseUrl}/api/v1/messages/${messageHash}`;
      const cacheDir = CacheRouter.getMessageByHashCacheDir(
        this.chainId,
        messageHash,
      );
      return await this.dataSource.get(cacheDir, url);
    } catch (error) {
      throw this.httpErrorFactory.from(error);
    }
  }

  async getMessagesBySafe(
    safeAddress: string,
    limit?: number | undefined,
    offset?: number | undefined,
  ): Promise<Page<Message>> {
    try {
      const url = `${this.baseUrl}/api/v1/safes/${safeAddress}/messages/`;
      const cacheDir = CacheRouter.getMessagesBySafeCacheDir(
        this.chainId,
        safeAddress,
        limit,
        offset,
      );
      return await this.dataSource.get(cacheDir, url, {
        params: {
          limit: limit,
          offset: offset,
        },
      });
    } catch (error) {
      throw this.httpErrorFactory.from(error);
    }
  }

  async postMultisigTransaction(
    address: string,
    proposeTransactionDto: ProposeTransactionDto,
  ): Promise<unknown> {
    try {
      const url = `${this.baseUrl}/api/v1/safes/${address}/multisig-transactions/`;
      return await this.networkService.post(url, {
        to: proposeTransactionDto.to,
        value: proposeTransactionDto.value,
        data: proposeTransactionDto.data,
        operation: proposeTransactionDto.operation,
        baseGas: proposeTransactionDto.baseGas,
        gasPrice: proposeTransactionDto.gasPrice,
        gasToken: proposeTransactionDto.gasToken,
        refundReceiver: proposeTransactionDto.refundReceiver,
        nonce: proposeTransactionDto.nonce,
        safeTxGas: proposeTransactionDto.safeTxGas,
        contractTransactionHash: proposeTransactionDto.safeTxHash,
        sender: proposeTransactionDto.sender,
        signature: proposeTransactionDto.signature,
      });
    } catch (error) {
      throw this.httpErrorFactory.from(error);
    }
  }

  async postMessage(
    safeAddress: string,
    message: unknown,
    safeAppId: number | null,
    signature: string,
  ): Promise<Message> {
    try {
      const url = `${this.baseUrl}/api/v1/safes/${safeAddress}/messages/`;
      const { data } = await this.networkService.post(url, {
        message,
        safeAppId,
        signature,
      });
      return data;
    } catch (error) {
      throw this.httpErrorFactory.from(error);
    }
  }

  async postMessageSignature(
    messageHash: string,
    signature: string,
  ): Promise<unknown> {
    try {
      const url = `${this.baseUrl}/api/v1/messages/${messageHash}/signatures/`;
      const { data } = await this.networkService.post(url, { signature });
      return data;
    } catch (error) {
      throw this.httpErrorFactory.from(error);
    }
  }
}

1	import { Backbone } from '../../domain/backbone/entities/backbone.entity';
2	import { Balance } from '../../domain/balances/entities/balance.entity';
3	import { MasterCopy } from '../../domain/chains/entities/master-copies.entity';
4	import { Collectible } from '../../domain/collectibles/entities/collectible.entity';
5	import { Contract } from '../../domain/contracts/entities/contract.entity';
6	import { DataDecoded } from '../../domain/data-decoder/entities/data-decoded.entity';
7	import { Delegate } from '../../domain/delegate/entities/delegate.entity';
8	import { Page } from '../../domain/entities/page.entity';
9	import { Estimation } from '../../domain/estimations/entities/estimation.entity';
10	import { GetEstimationDto } from '../../domain/estimations/entities/get-estimation.dto.entity';
11	import { ITransactionApi } from '../../domain/interfaces/transaction-api.interface';
12	import { Message } from '../../domain/messages/entities/message.entity';
13	import { Device } from '../../domain/notifications/entities/device.entity';
14	import { CreationTransaction } from '../../domain/safe/entities/creation-transaction.entity';
15	import { ModuleTransaction } from '../../domain/safe/entities/module-transaction.entity';
16	import { MultisigTransaction } from '../../domain/safe/entities/multisig-transaction.entity';
17	import { SafeList } from '../../domain/safe/entities/safe-list.entity';
18	import { Safe } from '../../domain/safe/entities/safe.entity';
19	import { Transaction } from '../../domain/safe/entities/transaction.entity';
20	import { Transfer } from '../../domain/safe/entities/transfer.entity';
21	import { Token } from '../../domain/tokens/entities/token.entity';
22	import { ProposeTransactionDto } from '../../domain/transactions/entities/propose-transaction.dto.entity';
23	import { CacheFirstDataSource } from '../cache/cache.first.data.source';
24	import { CacheRouter } from '../cache/cache.router';	25✔
25	import { ICacheService } from '../cache/cache.service.interface';
26	import { HttpErrorFactory } from '../errors/http-error-factory';
27	import { INetworkService } from '../network/network.service.interface';
28
29	export class TransactionApi implements ITransactionApi {	25✔
30	constructor(
31	private readonly chainId: string,	130✔
32	private readonly baseUrl: string,	130✔
33	private readonly dataSource: CacheFirstDataSource,	130✔
34	private readonly cacheService: ICacheService,	130✔
35	private readonly httpErrorFactory: HttpErrorFactory,	130✔
36	private readonly networkService: INetworkService,	130✔
37	) {}
38
39	async getBalances(
40	safeAddress: string,
41	trusted?: boolean,
42	excludeSpam?: boolean,
43	): Promise<Balance[]> {
44	try {	10✔
45	const cacheDir = CacheRouter.getBalanceCacheDir(	10✔
46	this.chainId,
47	safeAddress,
48	trusted,
49	excludeSpam,
50	);
51	const url = `${this.baseUrl}/api/v1/safes/${safeAddress}/balances/usd/`;	10✔
52	return await this.dataSource.get(cacheDir, url, {	10✔
53	params: {
54	trusted: trusted,
55	exclude_spam: excludeSpam,
56	},
57	});
58	} catch (error) {
59	throw this.httpErrorFactory.from(error);	2✔
60	}
61	}
62
63	async clearLocalBalances(safeAddress: string): Promise<void> {
64	const cacheKey = CacheRouter.getBalancesCacheKey(this.chainId, safeAddress);	3✔
65	await this.cacheService.deleteByKey(cacheKey);	3✔
66	}
67
68	async getDataDecoded(data: string, to: string): Promise<DataDecoded> {
69	try {	5✔
70	const url = `${this.baseUrl}/api/v1/data-decoder/`;	5✔
71	const { data: dataDecoded } = await this.networkService.post(url, {	5✔
72	data,
73	to,
74	});
75	return dataDecoded;	4✔
76	} catch (error) {
77	throw this.httpErrorFactory.from(error);	1✔
78	}
79	}
80
81	async getCollectibles(
82	safeAddress: string,
83	limit?: number,
84	offset?: number,
85	trusted?: boolean,
86	excludeSpam?: boolean,
87	): Promise<Page<Collectible>> {
88	try {	5✔
89	const cacheDir = CacheRouter.getCollectiblesCacheDir(	5✔
90	this.chainId,
91	safeAddress,
92	limit,
93	offset,
94	trusted,
95	excludeSpam,
96	);
97	const url = `${this.baseUrl}/api/v2/safes/${safeAddress}/collectibles/`;	5✔
98	return await this.dataSource.get(cacheDir, url, {	5✔
99	params: {
100	limit: limit,
101	offset: offset,
102	trusted: trusted,
103	exclude_spam: excludeSpam,
104	},
105	});
106	} catch (error) {
107	throw this.httpErrorFactory.from(error);	2✔
108	}
109	}
110
111	async getBackbone(): Promise<Backbone> {
112	try {	4✔
113	const cacheDir = CacheRouter.getBackboneCacheDir(this.chainId);	4✔
114	const url = `${this.baseUrl}/api/v1/about`;	4✔
115	return await this.dataSource.get(cacheDir, url);	4✔
116	} catch (error) {
117	throw this.httpErrorFactory.from(error);	2✔
118	}
119	}
120
121	async getMasterCopies(): Promise<MasterCopy[]> {
122	try {	14✔
123	const cacheDir = CacheRouter.getMasterCopiesCacheDir(this.chainId);	14✔
124	const url = `${this.baseUrl}/api/v1/about/master-copies/`;	14✔
125	return await this.dataSource.get(cacheDir, url);	14✔
126	} catch (error) {
127	throw this.httpErrorFactory.from(error);	1✔
128	}
129	}
130
131	async getSafe(safeAddress: string): Promise<Safe> {
132	try {	54✔
133	const cacheDir = CacheRouter.getSafeCacheDir(this.chainId, safeAddress);	54✔
134	const url = `${this.baseUrl}/api/v1/safes/${safeAddress}`;	54✔
135	return await this.dataSource.get(cacheDir, url);	54✔
136	} catch (error) {
137	throw this.httpErrorFactory.from(error);	2✔
138	}
139	}
140
141	async getContract(contractAddress: string): Promise<Contract> {
142	try {	210✔
143	const cacheDir = CacheRouter.getContractCacheDir(	210✔
144	this.chainId,
145	contractAddress,
146	);
147	const url = `${this.baseUrl}/api/v1/contracts/${contractAddress}`;	210✔
148	return await this.dataSource.get(cacheDir, url);	210✔
149	} catch (error) {
150	throw this.httpErrorFactory.from(error);	118✔
151	}
152	}
153
154	async getDelegates(
155	safeAddress?: string,
156	delegate?: string,
157	delegator?: string,
158	label?: string,
159	limit?: number,
160	offset?: number,
161	): Promise<Page<Delegate>> {
162	try {	3✔
163	const cacheDir = CacheRouter.getDelegatesCacheDir(	3✔
164	this.chainId,
165	safeAddress,
166	delegate,
167	delegator,
168	label,
169	limit,
170	offset,
171	);
172	const url = `${this.baseUrl}/api/v1/delegates/`;	3✔
173	return await this.dataSource.get(cacheDir, url, {	3✔
174	params: {
175	safe: safeAddress,
176	delegate: delegate,
177	delegator: delegator,
178	label: label,
179	limit: limit,
180	offset: offset,
181	},
182	});
183	} catch (error) {
184	throw this.httpErrorFactory.from(error);	×
185	}
186	}
187
188	async postDelegate(
189	safeAddress?: string,
190	delegate?: string,
191	delegator?: string,
192	signature?: string,
193	label?: string,
194	): Promise<unknown> {
195	try {	4✔
196	const url = `${this.baseUrl}/api/v1/delegates/`;	4✔
197	return await this.networkService.post(url, {	4✔
198	safe: safeAddress,
199	delegate: delegate,
200	delegator: delegator,
201	signature: signature,
202	label: label,
203	});
204	} catch (error) {
205	throw this.httpErrorFactory.from(error);	2✔
206	}
207	}
208
209	async deleteDelegate(
210	delegate: string,
211	delegator: string,
212	signature: string,
213	): Promise<unknown> {
214	try {	3✔
215	const url = `${this.baseUrl}/api/v1/delegates/${delegate}`;	3✔
216	return await this.networkService.delete(url, {	3✔
217	delegate: delegate,
218	delegator: delegator,
219	signature: signature,
220	});
221	} catch (error) {
222	throw this.httpErrorFactory.from(error);	2✔
223	}
224	}
225
226	async deleteSafeDelegate(
227	delegate: string,
228	safeAddress: string,
229	signature: string,
230	): Promise<void> {
231	try {	2✔
232	const url = `${this.baseUrl}/api/v1/safes/${safeAddress}/delegates/${delegate}`;	2✔
233	return await this.networkService.delete(url, {	2✔
234	delegate: delegate,
235	safe: safeAddress,
236	signature: signature,
237	});
238	} catch (error) {
239	throw this.httpErrorFactory.from(error);	1✔
240	}
241	}
242
243	async getTransfers(
244	safeAddress: string,
245	onlyErc20: boolean,
246	onlyErc721: boolean,
247	limit?: number,
248	offset?: number,
249	): Promise<Page<Transfer>> {
250	try {	11✔
251	const cacheDir = CacheRouter.getTransfersCacheDir(	11✔
252	this.chainId,
253	safeAddress,
254	onlyErc20,
255	onlyErc721,
256	limit,
257	offset,
258	);
259	const url = `${this.baseUrl}/api/v1/safes/${safeAddress}/transfers/`;	11✔
260	return await this.dataSource.get(cacheDir, url, {	11✔
261	params: {
262	erc20: onlyErc20,
263	erc721: onlyErc721,
264	limit: limit,
265	offset: offset,
266	},
267	});
268	} catch (error) {
269	throw this.httpErrorFactory.from(error);	×
270	}
271	}
272
273	async getIncomingTransfers(
274	safeAddress: string,
275	executionDateGte?: string,
276	executionDateLte?: string,
277	to?: string,
278	value?: string,
279	tokenAddress?: string,
280	limit?: number,
281	offset?: number,
282	): Promise<Page<Transfer>> {
283	try {	8✔
284	const cacheDir = CacheRouter.getIncomingTransfersCacheDir(	8✔
285	this.chainId,
286	safeAddress,
287	executionDateGte,
288	executionDateLte,
289	to,
290	value,
291	tokenAddress,
292	limit,
293	offset,
294	);
295	const url = `${this.baseUrl}/api/v1/safes/${safeAddress}/incoming-transfers/`;	8✔
296	return await this.dataSource.get(cacheDir, url, {	8✔
297	params: {
298	execution_date__gte: executionDateGte,
299	execution_date__lte: executionDateLte,
300	to,
301	value,
302	tokenAddress,
303	limit,
304	offset,
305	},
306	});
307	} catch (error) {
308	throw this.httpErrorFactory.from(error);	1✔
309	}
310	}
311
312	async getModuleTransactions(
313	safeAddress: string,
314	to?: string,
315	module?: string,
316	limit?: number,
317	offset?: number,
318	): Promise<Page<ModuleTransaction>> {
319	try {	4✔
320	const cacheDir = CacheRouter.getModuleTransactionsCacheDir(	4✔
321	this.chainId,
322	safeAddress,
323	to,
324	module,
325	limit,
326	offset,
327	);
328	const url = `${this.baseUrl}/api/v1/safes/${safeAddress}/module-transactions/`;	4✔
329	return await this.dataSource.get(cacheDir, url, {	4✔
330	params: {
331	to,
332	module,
333	limit,
334	offset,
335	},
336	});
337	} catch (error) {
338	throw this.httpErrorFactory.from(error);	1✔
339	}
340	}
341
342	async getMultisigTransactions(
343	safeAddress: string,
344	ordering?: string,
345	executed?: boolean,
346	trusted?: boolean,
347	executionDateGte?: string,
348	executionDateLte?: string,
349	to?: string,
350	value?: string,
351	nonce?: string,
352	limit?: number,
353	offset?: number,
354	): Promise<Page<MultisigTransaction>> {
355	try {	25✔
356	const cacheDir = CacheRouter.getMultisigTransactionsCacheDir(	25✔
357	this.chainId,
358	safeAddress,
359	ordering,
360	executed,
361	trusted,
362	executionDateGte,
363	executionDateLte,
364	to,
365	value,
366	nonce,
367	limit,
368	offset,
369	);
370	const url = `${this.baseUrl}/api/v1/safes/${safeAddress}/multisig-transactions/`;	25✔
371	return await this.dataSource.get(cacheDir, url, {	25✔
372	params: {
373	safe: safeAddress,
374	ordering,
375	executed,
376	trusted,
377	execution_date__gte: executionDateGte,
378	execution_date__lte: executionDateLte,
379	to,
380	value,
381	nonce,
382	limit,
383	offset,
384	},
385	});
386	} catch (error) {
387	throw this.httpErrorFactory.from(error);	1✔
388	}
389	}
390
391	async getMultisigTransaction(
392	safeTransactionHash: string,
393	): Promise<MultisigTransaction> {
394	try {	1✔
395	const cacheDir = CacheRouter.getMultisigTransactionsCacheDir(	1✔
396	this.chainId,
397	safeTransactionHash,
398	);
399	const url = `${this.baseUrl}/api/v1/multisig-transactions/${safeTransactionHash}/`;	1✔
400	return await this.dataSource.get(cacheDir, url);	1✔
401	} catch (error) {
402	throw this.httpErrorFactory.from(error);	×
403	}
404	}
405
406	async getCreationTransaction(
407	safeAddress: string,
408	): Promise<CreationTransaction> {
409	try {	2✔
410	const cacheDir = CacheRouter.getCreationTransactionCacheDir(	2✔
411	this.chainId,
412	safeAddress,
413	);
414	const url = `${this.baseUrl}/api/v1/safes/${safeAddress}/creation/`;	2✔
415	return await this.dataSource.get(cacheDir, url);	2✔
416	} catch (error) {
417	throw this.httpErrorFactory.from(error);	×
418	}
419	}
420
421	async getAllTransactions(
422	safeAddress: string,
423	ordering?: string,
424	executed?: boolean,
425	queued?: boolean,
426	limit?: number,
427	offset?: number,
428	): Promise<Page<Transaction>> {
429	try {	18✔
430	const cacheDir = CacheRouter.getAllTransactionsCacheDir(	18✔
431	this.chainId,
432	safeAddress,
433	ordering,
434	executed,
435	queued,
436	limit,
437	offset,
438	);
439	const url = `${this.baseUrl}/api/v1/safes/${safeAddress}/all-transactions/`;	18✔
440	return await this.dataSource.get(cacheDir, url, {	18✔
441	params: {
442	safe: safeAddress,
443	ordering: ordering,
444	executed: executed,
445	queued: queued,
446	limit: limit,
447	offset: offset,
448	},
449	});
450	} catch (error) {
451	throw this.httpErrorFactory.from(error);	1✔
452	}
453	}
454
455	async getToken(address: string): Promise<Token> {
456	try {	16✔
457	const cacheDir = CacheRouter.getTokenCacheDir(this.chainId, address);	16✔
458	const url = `${this.baseUrl}/api/v1/tokens/${address}`;	16✔
459	return await this.dataSource.get(cacheDir, url);	16✔
460	} catch (error) {
461	throw this.httpErrorFactory.from(error);	×
462	}
463	}
464
465	async getTokens(limit?: number, offset?: number): Promise<Page<Token>> {
466	try {	×
467	const cacheDir = CacheRouter.getTokensCacheDir(	×
468	this.chainId,
469	limit,
470	offset,
471	);
472	const url = `${this.baseUrl}/api/v1/tokens/`;	×
473	return await this.dataSource.get(cacheDir, url, {	×
474	params: {
475	limit: limit,
476	offset: offset,
477	},
478	});
479	} catch (error) {
480	throw this.httpErrorFactory.from(error);	×
481	}
482	}
483
484	async getSafesByOwner(ownerAddress: string): Promise<SafeList> {
485	try {	4✔
486	const cacheDir = CacheRouter.getSafesByOwnerCacheDir(	4✔
487	this.chainId,
488	ownerAddress,
489	);
490	const url = `${this.baseUrl}/api/v1/owners/${ownerAddress}/safes/`;	4✔
491	return await this.dataSource.get(cacheDir, url);	4✔
492	} catch (error) {
493	throw this.httpErrorFactory.from(error);	1✔
494	}
495	}
496
497	async postDeviceRegistration(
498	device: Device,
499	safes: string[],
500	signatures: string[],
501	): Promise<void> {
502	try {	20✔
503	const url = `${this.baseUrl}/api/v1/notifications/devices/`;	20✔
504	await this.networkService.post(url, {	20✔
505	uuid: device.uuid,
506	cloudMessagingToken: device.cloudMessagingToken,
507	buildNumber: device.buildNumber,
508	bundle: device.bundle,
509	deviceType: device.deviceType,
510	version: device.version,
511	timestamp: device.timestamp,
512	safes,
513	signatures,
514	});
515	} catch (error) {
516	throw this.httpErrorFactory.from(error);	5✔
517	}
518	}
519
520	async deleteDeviceRegistration(
521	uuid: string,
522	safeAddress: string,
523	): Promise<void> {
524	try {	2✔
525	const url = `${this.baseUrl}/api/v1/notifications/devices/${uuid}/safes/${safeAddress}`;	2✔
526	await this.networkService.delete(url);	2✔
527	} catch (error) {
528	throw this.httpErrorFactory.from(error);	1✔
529	}
530	}
531
532	async getEstimation(
533	address: string,
534	getEstimationDto: GetEstimationDto,
535	): Promise<Estimation> {
536	try {	4✔
537	const url = `${this.baseUrl}/api/v1/safes/${address}/multisig-transactions/estimations/`;	4✔
538	const { data: estimation } = await this.networkService.post(url, {	4✔
539	to: getEstimationDto.to,
540	value: getEstimationDto.value,
541	data: getEstimationDto.data,
542	operation: getEstimationDto.operation,
543	});
544	return estimation;	4✔
545	} catch (error) {
546	throw this.httpErrorFactory.from(error);	×
547	}
548	}
549
550	async getMessageByHash(messageHash: string): Promise<Message> {
551	try {	6✔
552	const url = `${this.baseUrl}/api/v1/messages/${messageHash}`;	6✔
553	const cacheDir = CacheRouter.getMessageByHashCacheDir(	6✔
554	this.chainId,
555	messageHash,
556	);
557	return await this.dataSource.get(cacheDir, url);	6✔
558	} catch (error) {
559	throw this.httpErrorFactory.from(error);	×
560	}
561	}
562
563	async getMessagesBySafe(
564	safeAddress: string,
565	limit?: number \| undefined,
566	offset?: number \| undefined,
567	): Promise<Page<Message>> {
568	try {	3✔
569	const url = `${this.baseUrl}/api/v1/safes/${safeAddress}/messages/`;	3✔
570	const cacheDir = CacheRouter.getMessagesBySafeCacheDir(	3✔
571	this.chainId,
572	safeAddress,
573	limit,
574	offset,
575	);
576	return await this.dataSource.get(cacheDir, url, {	3✔
577	params: {
578	limit: limit,
579	offset: offset,
580	},
581	});
582	} catch (error) {
583	throw this.httpErrorFactory.from(error);	×
584	}
585	}
586
587	async postMultisigTransaction(
588	address: string,
589	proposeTransactionDto: ProposeTransactionDto,
590	): Promise<unknown> {
591	try {	1✔
592	const url = `${this.baseUrl}/api/v1/safes/${address}/multisig-transactions/`;	1✔
593	return await this.networkService.post(url, {	1✔
594	to: proposeTransactionDto.to,
595	value: proposeTransactionDto.value,
596	data: proposeTransactionDto.data,
597	operation: proposeTransactionDto.operation,
598	baseGas: proposeTransactionDto.baseGas,
599	gasPrice: proposeTransactionDto.gasPrice,
600	gasToken: proposeTransactionDto.gasToken,
601	refundReceiver: proposeTransactionDto.refundReceiver,
602	nonce: proposeTransactionDto.nonce,
603	safeTxGas: proposeTransactionDto.safeTxGas,
604	contractTransactionHash: proposeTransactionDto.safeTxHash,
605	sender: proposeTransactionDto.sender,
606	signature: proposeTransactionDto.signature,
607	});
608	} catch (error) {
UNCOV 609	throw this.httpErrorFactory.from(error);	×
610	}
611	}
612
613	async postMessage(
614	safeAddress: string,
615	message: unknown,
616	safeAppId: number \| null,
617	signature: string,
618	): Promise<Message> {
619	try {	2✔
620	const url = `${this.baseUrl}/api/v1/safes/${safeAddress}/messages/`;	2✔
621	const { data } = await this.networkService.post(url, {	2✔
622	message,
623	safeAppId,
624	signature,
625	});
626	return data;	1✔
627	} catch (error) {
628	throw this.httpErrorFactory.from(error);	1✔
629	}
630	}
631
632	async postMessageSignature(
633	messageHash: string,
634	signature: string,
635	): Promise<unknown> {
636	try {	2✔
637	const url = `${this.baseUrl}/api/v1/messages/${messageHash}/signatures/`;	2✔
638	const { data } = await this.networkService.post(url, { signature });	2✔
639	return data;	1✔
640	} catch (error) {
641	throw this.httpErrorFactory.from(error);	1✔
642	}
643	}
644	}

safe-global / safe-client-gateway-nest / 4946384134

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