1989

pending completion

Build # 1989

Build Type

Pull #767

travis-ci-com

Committed by

web-flow

Commit Message

<a href="https://github.com/nemtech/symbol-sdk-typescript-javascript/commit/<a class=hub.com/nemtech/symbol-sdk-typescript-javascript/commit/<a class="double-link" href="https://git"><a class=hub.com/nemtech/symbol-sdk-typescript-javascript/commit/<a class="double-link" href="https://git"><a class=hub.com/nemtech/symbol-sdk-typescript-javascript/commit/5223a4512fcb5492248e2e321d2fc6e684db6700">5223a4512">&lt;a href=&quot;https://github.com/nemtech/symbol-sdk-typescript-javascript/commit/</a><a class="double-link" href="https://github.com/nemtech/symbol-sdk-typescript-javascript/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/nemtech/symbol-sdk-typescript-javascript/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/nemtech/symbol-sdk-typescript-javascript/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/nemtech/symbol-sdk-typescript-javascript/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/nemtech/symbol-sdk-typescript-javascript/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/nemtech/symbol-sdk-typescript-javascript/commit/5223a4512fcb5492248e2e321d2fc6e684db6700">5223a4512</a><a href="https://github.com/nemtech/symbol-sdk-typescript-javascript/commit/5223a4512fcb5492248e2e321d2fc6e684db6700">&quot;&gt;&amp;lt;a href=&amp;quot;https://github.com/nemtech/symbol-sdk-typescript-javascript/commit/&lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/nemtech/symbol-sdk-typescript-javascript/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/nemtech/symbol-sdk-typescript-javascript/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/nemtech/symbol-sdk-typescript-javascript/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/nemtech/symbol-sdk-typescript-javascript/commit/5223a4512fcb5492248e2e321d2fc6e684db6700&quot;&gt;5223a4512&lt;/a&gt;&lt;a href=&quot;https://github.com/nemtech/symbol-sdk-ty... (continued)

Pull Request Pull Request #767: Added blockAnnouncement to repository config

Run Details

1753 of 2166 branches covered (80.93%)

Branch coverage included in aggregate %.

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

5218 of 5508 relevant lines covered (94.73%)

26262.4 hits per line

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

80.65

/src/infrastructure/TransactionHttp.ts

/*
 * Copyright 2018 NEM
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

import { Observable } from 'rxjs';
import { mergeMap } from 'rxjs/operators';
import {
    BlockInfoDTO,
    BlockRoutesApi,
    TransactionInfoDTO,
    TransactionPage,
    TransactionRoutesApi,
} from 'symbol-openapi-typescript-fetch-client';
import { DtoMapping } from '../core/utils';
import {
    CosignatureSignedTransaction,
    SignedTransaction,
    Transaction,
    TransactionAnnounceResponse,
    TransactionInfo,
    TransactionType,
} from '../model/transaction';
import { Http } from './Http';
import { Page } from './Page';
import { TransactionPaginationStreamer } from './paginationStreamer';
import { TransactionSearchCriteria } from './searchCriteria';
import { CreateTransactionFromDTO } from './transaction';
import { TransactionGroup } from './TransactionGroup';
import { TransactionRepository } from './TransactionRepository';

/**
 * Transaction http repository.
 *
 * @since 1.0
 */
export class TransactionHttp extends Http implements TransactionRepository {
    /**
     * @internal
     * Symbol openapi typescript-node client transaction routes api
     */
    private transactionRoutesApi: TransactionRoutesApi;

    /**
     * @internal
     * Symbol openapi typescript-node client blockchain routes api
     */
    private blockRoutesApi: BlockRoutesApi;

    /**
     * Constructor
     * @param url Base catapult-rest url
     * @param fetchApi fetch function to be used when performing rest requests.
     * @param blockAnnouncement if true, any announcement will be rejected.
     */
    constructor(url: string, fetchApi?: any, private readonly blockAnnouncement?: boolean) {
        super(url, fetchApi);
        this.transactionRoutesApi = new TransactionRoutesApi(this.config());
        this.blockRoutesApi = new BlockRoutesApi(this.config());
    }

    /**
     * Gets a transaction for a transactionId
     * @param transactionId - Transaction id or hash.
     * @param transactionGroup - Transaction group.
     * @returns Observable<Transaction>
     */
    public getTransaction(transactionId: string, transactionGroup: TransactionGroup): Observable<Transaction> {
        return this.call(this.getTransactionByGroup(transactionId, transactionGroup), (body) => CreateTransactionFromDTO(body));
    }

    /**
     * Gets an array of transactions for different transaction ids
     * @param transactionIds - Array of transactions id and/or hash.
     * @param transactionGroup - Transaction group.
     * @returns Observable<Transaction[]>
     */
    public getTransactionsById(transactionIds: string[], transactionGroup: TransactionGroup): Observable<Transaction[]> {
        const transactionIdsBody = {
            transactionIds,
        };

        switch (transactionGroup) {
            case TransactionGroup.Confirmed:
                return this.call(this.transactionRoutesApi.getConfirmedTransactions(transactionIdsBody), (body) =>
                    body.map((transactionDTO) => {
                        return CreateTransactionFromDTO(transactionDTO);
                    }),
                );
            case TransactionGroup.Unconfirmed:
                return this.call(this.transactionRoutesApi.getUnconfirmedTransactions(transactionIdsBody), (body) =>
                    body.map((transactionDTO) => {
                        return CreateTransactionFromDTO(transactionDTO);
                    }),
                );
            case TransactionGroup.Partial:
                return this.call(this.transactionRoutesApi.getPartialTransactions(transactionIdsBody), (body) =>
                    body.map((transactionDTO) => {
                        return CreateTransactionFromDTO(transactionDTO);
                    }),
                );
        }
    }

    /**
     * Send a signed transaction
     * @param signedTransaction - Signed transaction
     * @returns Observable<TransactionAnnounceResponse>
     */
    public announce(signedTransaction: SignedTransaction): Observable<TransactionAnnounceResponse> {
        if (this.blockAnnouncement) {
            throw new Error('It is not allowed to announce transactions.');
        }
        if (signedTransaction.type === TransactionType.AGGREGATE_BONDED) {
            throw new Error("Announcing aggregate bonded transaction should use 'announceAggregateBonded'");
        }
        return this.call(
            this.transactionRoutesApi.announceTransaction(signedTransaction),
            (body) => new TransactionAnnounceResponse(body.message),
        );
    }

    /**
     * Send a signed transaction with missing signatures
     * @param signedTransaction - Signed transaction
     * @returns Observable<TransactionAnnounceResponse>
     */
    public announceAggregateBonded(signedTransaction: SignedTransaction): Observable<TransactionAnnounceResponse> {
        if (this.blockAnnouncement) {
            throw new Error('It is not allowed to announce transactions.');
        }
        if (signedTransaction.type !== TransactionType.AGGREGATE_BONDED) {
            throw new Error('Only Transaction Type 0x4241 is allowed for announce aggregate bonded');
        }
        return this.call(
            this.transactionRoutesApi.announcePartialTransaction(signedTransaction),
            (body) => new TransactionAnnounceResponse(body.message),
        );
    }

    /**
     * Send a cosignature signed transaction of an already announced transaction
     * @param cosignatureSignedTransaction - Cosignature signed transaction
     * @returns Observable<TransactionAnnounceResponse>
     */
    public announceAggregateBondedCosignature(
        cosignatureSignedTransaction: CosignatureSignedTransaction,
    ): Observable<TransactionAnnounceResponse> {
        if (this.blockAnnouncement) {
            throw new Error('It is not allowed to announce transactions.');
        }
        const cosignature = {
            parentHash: cosignatureSignedTransaction.parentHash,
            signerPublicKey: cosignatureSignedTransaction.signerPublicKey,
            signature: cosignatureSignedTransaction.signature,
            version: cosignatureSignedTransaction.version.toString(),
        };
        return this.call(
            this.transactionRoutesApi.announceCosignatureTransaction(cosignature),
            (body) => new TransactionAnnounceResponse(body.message),
        );
    }

    /**
     * Gets a transaction's effective paid fee
     * @param transactionId - Transaction id or hash.
     * @returns Observable<number>
     */
    public getTransactionEffectiveFee(transactionId: string): Observable<number> {
        return this.call(this.getTransactionByGroup(transactionId, TransactionGroup.Confirmed), CreateTransactionFromDTO).pipe(
            mergeMap((transaction) => {
                // now read block details
                return this.call(
                    this.blockRoutesApi.getBlockByHeight((transaction.transactionInfo as TransactionInfo).height.toString()),
                    (blockDTO: BlockInfoDTO) => {
                        // @see https://nemtech.github.io/concepts/transaction.html#fees
                        // effective_fee = feeMultiplier x transaction::size
                        return blockDTO.block.feeMultiplier * transaction.size;
                    },
                );
            }),
        );
    }

    /**
     * Returns an array of transactions.
     * @summary Get transactions
     * @param criteria Transaction search criteria
     * @returns {Observable<Page<Transaction>>}
     */
    public search(criteria: TransactionSearchCriteria): Observable<Page<Transaction>> {
        return this.call(this.searchTransactionByGroup(criteria), (body) =>
            super.toPage(body.pagination, body.data, CreateTransactionFromDTO),
        );
    }
    public streamer(): TransactionPaginationStreamer {
        return new TransactionPaginationStreamer(this);
    }

    /**
     * @internal
     * Gets a transaction info
     * @param transactionId - Transaction id or hash.
     * @param transactionGroup - Transaction group.
     * @returns Promise<{response: http.ClientResponse; body: TransactionInfoDTO;}>
     */
    private getTransactionByGroup(transactionId: string, transactionGroup: TransactionGroup): Promise<TransactionInfoDTO> {
        switch (transactionGroup) {
            case TransactionGroup.Confirmed:
                return this.transactionRoutesApi.getConfirmedTransaction(transactionId);
            case TransactionGroup.Unconfirmed:
                return this.transactionRoutesApi.getUnconfirmedTransaction(transactionId);
            case TransactionGroup.Partial:
                return this.transactionRoutesApi.getPartialTransaction(transactionId);
        }
    }

    /**
     * @internal
     * Gets a transaction search result
     * @param criteria - the criteria.
     * @returns Promise<{response: http.ClientResponse; body: TransactionInfoDTO;}>
     */
    private searchTransactionByGroup(criteria: TransactionSearchCriteria): Promise<TransactionPage> {
        switch (criteria.group) {
            case TransactionGroup.Confirmed:
                return this.transactionRoutesApi.searchConfirmedTransactions(
                    criteria.address?.plain(),
                    criteria.recipientAddress?.plain(),
                    criteria.signerPublicKey,
                    criteria.height?.toString(),
                    criteria.fromHeight?.toString(),
                    criteria.toHeight?.toString(),
                    criteria.fromTransferAmount?.toString(),
                    criteria.toTransferAmount?.toString(),
                    criteria.type?.map((type) => type.valueOf()),
                    criteria.embedded,
                    criteria.transferMosaicId?.toHex(),
                    criteria.pageSize,
                    criteria.pageNumber,
                    criteria.offset,
                    DtoMapping.mapEnum(criteria.order),
                );
            case TransactionGroup.Unconfirmed:
                return this.transactionRoutesApi.searchUnconfirmedTransactions(
                    criteria.address?.plain(),
                    criteria.recipientAddress?.plain(),
                    criteria.signerPublicKey,
                    criteria.height?.toString(),
                    criteria.fromHeight?.toString(),
                    criteria.toHeight?.toString(),
                    criteria.fromTransferAmount?.toString(),
                    criteria.toTransferAmount?.toString(),
                    criteria.type?.map((type) => type.valueOf()),
                    criteria.embedded,
                    criteria.transferMosaicId?.toHex(),
                    criteria.pageSize,
                    criteria.pageNumber,
                    criteria.offset,
                    DtoMapping.mapEnum(criteria.order),
                );
            case TransactionGroup.Partial:
                return this.transactionRoutesApi.searchPartialTransactions(
                    criteria.address?.plain(),
                    criteria.recipientAddress?.plain(),
                    criteria.signerPublicKey,
                    criteria.height?.toString(),
                    criteria.fromHeight?.toString(),
                    criteria.toHeight?.toString(),
                    criteria.fromTransferAmount?.toString(),
                    criteria.toTransferAmount?.toString(),
                    criteria.type?.map((type) => type.valueOf()),
                    criteria.embedded,
                    criteria.transferMosaicId?.toHex(),
                    criteria.pageSize,
                    criteria.pageNumber,
                    criteria.offset,
                    DtoMapping.mapEnum(criteria.order),
                );
        }
    }
}

1	/*
2	* Copyright 2018 NEM
3	*
4	* Licensed under the Apache License, Version 2.0 (the "License");
5	* you may not use this file except in compliance with the License.
6	* You may obtain a copy of the License at
7	*
8	* http://www.apache.org/licenses/LICENSE-2.0
9	*
10	* Unless required by applicable law or agreed to in writing, software
11	* distributed under the License is distributed on an "AS IS" BASIS,
12	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13	* See the License for the specific language governing permissions and
14	* limitations under the License.
15	*/
16
17	import { Observable } from 'rxjs';
18	import { mergeMap } from 'rxjs/operators';	1✔
19	import {	1✔
20	BlockInfoDTO,
21	BlockRoutesApi,
22	TransactionInfoDTO,
23	TransactionPage,
24	TransactionRoutesApi,
25	} from 'symbol-openapi-typescript-fetch-client';
26	import { DtoMapping } from '../core/utils';	1✔
27	import {	1✔
28	CosignatureSignedTransaction,
29	SignedTransaction,
30	Transaction,
31	TransactionAnnounceResponse,
32	TransactionInfo,
33	TransactionType,
34	} from '../model/transaction';
35	import { Http } from './Http';	1✔
36	import { Page } from './Page';
37	import { TransactionPaginationStreamer } from './paginationStreamer';	1✔
38	import { TransactionSearchCriteria } from './searchCriteria';
39	import { CreateTransactionFromDTO } from './transaction';	1✔
40	import { TransactionGroup } from './TransactionGroup';	1✔
41	import { TransactionRepository } from './TransactionRepository';
42
43	/**
44	* Transaction http repository.
45	*
46	* @since 1.0
47	*/
48	export class TransactionHttp extends Http implements TransactionRepository {	1✔
49	/**
50	* @internal
51	* Symbol openapi typescript-node client transaction routes api
52	*/
53	private transactionRoutesApi: TransactionRoutesApi;
54
55	/**
56	* @internal
57	* Symbol openapi typescript-node client blockchain routes api
58	*/
59	private blockRoutesApi: BlockRoutesApi;
60
61	/**
62	* Constructor
63	* @param url Base catapult-rest url
64	* @param fetchApi fetch function to be used when performing rest requests.
65	* @param blockAnnouncement if true, any announcement will be rejected.
66	*/
67	constructor(url: string, fetchApi?: any, private readonly blockAnnouncement?: boolean) {	6✔
68	super(url, fetchApi);	6✔
69	this.transactionRoutesApi = new TransactionRoutesApi(this.config());	6✔
70	this.blockRoutesApi = new BlockRoutesApi(this.config());	6✔
71	}
72
73	/**
74	* Gets a transaction for a transactionId
75	* @param transactionId - Transaction id or hash.
76	* @param transactionGroup - Transaction group.
77	* @returns Observable<Transaction>
78	*/
79	public getTransaction(transactionId: string, transactionGroup: TransactionGroup): Observable<Transaction> {
80	return this.call(this.getTransactionByGroup(transactionId, transactionGroup), (body) => CreateTransactionFromDTO(body));	5✔
81	}
82
83	/**
84	* Gets an array of transactions for different transaction ids
85	* @param transactionIds - Array of transactions id and/or hash.
86	* @param transactionGroup - Transaction group.
87	* @returns Observable<Transaction[]>
88	*/
89	public getTransactionsById(transactionIds: string[], transactionGroup: TransactionGroup): Observable<Transaction[]> {
90	const transactionIdsBody = {	4✔
91	transactionIds,
92	};
93
94	switch (transactionGroup) {	4✔
95	case TransactionGroup.Confirmed:	4✔
96	return this.call(this.transactionRoutesApi.getConfirmedTransactions(transactionIdsBody), (body) =>	2✔
97	body.map((transactionDTO) => {	1✔
98	return CreateTransactionFromDTO(transactionDTO);	1✔
99	}),
100	);
101	case TransactionGroup.Unconfirmed:
102	return this.call(this.transactionRoutesApi.getUnconfirmedTransactions(transactionIdsBody), (body) =>	1✔
103	body.map((transactionDTO) => {	1✔
104	return CreateTransactionFromDTO(transactionDTO);	1✔
105	}),
106	);
107	case TransactionGroup.Partial:
108	return this.call(this.transactionRoutesApi.getPartialTransactions(transactionIdsBody), (body) =>	1✔
109	body.map((transactionDTO) => {	1✔
110	return CreateTransactionFromDTO(transactionDTO);	1✔
111	}),
112	);
113	}
114	}
115
116	/**
117	* Send a signed transaction
118	* @param signedTransaction - Signed transaction
119	* @returns Observable<TransactionAnnounceResponse>
120	*/
121	public announce(signedTransaction: SignedTransaction): Observable<TransactionAnnounceResponse> {
122	if (this.blockAnnouncement) {	3!
123	throw new Error('It is not allowed to announce transactions.');	×
124	}
125	if (signedTransaction.type === TransactionType.AGGREGATE_BONDED) {	3✔
126	throw new Error("Announcing aggregate bonded transaction should use 'announceAggregateBonded'");	1✔
127	}
128	return this.call(	2✔
129	this.transactionRoutesApi.announceTransaction(signedTransaction),
130	(body) => new TransactionAnnounceResponse(body.message),	1✔
131	);
132	}
133
134	/**
135	* Send a signed transaction with missing signatures
136	* @param signedTransaction - Signed transaction
137	* @returns Observable<TransactionAnnounceResponse>
138	*/
139	public announceAggregateBonded(signedTransaction: SignedTransaction): Observable<TransactionAnnounceResponse> {
140	if (this.blockAnnouncement) {	2!
141	throw new Error('It is not allowed to announce transactions.');	×
142	}
143	if (signedTransaction.type !== TransactionType.AGGREGATE_BONDED) {	2✔
144	throw new Error('Only Transaction Type 0x4241 is allowed for announce aggregate bonded');	1✔
145	}
146	return this.call(	1✔
147	this.transactionRoutesApi.announcePartialTransaction(signedTransaction),
148	(body) => new TransactionAnnounceResponse(body.message),	1✔
149	);
150	}
151
152	/**
153	* Send a cosignature signed transaction of an already announced transaction
154	* @param cosignatureSignedTransaction - Cosignature signed transaction
155	* @returns Observable<TransactionAnnounceResponse>
156	*/
157	public announceAggregateBondedCosignature(
158	cosignatureSignedTransaction: CosignatureSignedTransaction,
159	): Observable<TransactionAnnounceResponse> {
160	if (this.blockAnnouncement) {	3!
161	throw new Error('It is not allowed to announce transactions.');	×
162	}
163	const cosignature = {	3✔
164	parentHash: cosignatureSignedTransaction.parentHash,
165	signerPublicKey: cosignatureSignedTransaction.signerPublicKey,
166	signature: cosignatureSignedTransaction.signature,
167	version: cosignatureSignedTransaction.version.toString(),
168	};
169	return this.call(	3✔
170	this.transactionRoutesApi.announceCosignatureTransaction(cosignature),
171	(body) => new TransactionAnnounceResponse(body.message),	1✔
172	);
173	}
174
175	/**
176	* Gets a transaction's effective paid fee
177	* @param transactionId - Transaction id or hash.
178	* @returns Observable<number>
179	*/
180	public getTransactionEffectiveFee(transactionId: string): Observable<number> {
181	return this.call(this.getTransactionByGroup(transactionId, TransactionGroup.Confirmed), CreateTransactionFromDTO).pipe(	3✔
182	mergeMap((transaction) => {
183	// now read block details
184	return this.call(	1✔
185	this.blockRoutesApi.getBlockByHeight((transaction.transactionInfo as TransactionInfo).height.toString()),
186	(blockDTO: BlockInfoDTO) => {
187	// @see https://nemtech.github.io/concepts/transaction.html#fees
188	// effective_fee = feeMultiplier x transaction::size
189	return blockDTO.block.feeMultiplier * transaction.size;	1✔
190	},
191	);
192	}),
193	);
194	}
195
196	/**
197	* Returns an array of transactions.
198	* @summary Get transactions
199	* @param criteria Transaction search criteria
200	* @returns {Observable<Page<Transaction>>}
201	*/
202	public search(criteria: TransactionSearchCriteria): Observable<Page<Transaction>> {
203	return this.call(this.searchTransactionByGroup(criteria), (body) =>	3✔
204	super.toPage(body.pagination, body.data, CreateTransactionFromDTO),	3✔
205	);
206	}
207	public streamer(): TransactionPaginationStreamer {
208	return new TransactionPaginationStreamer(this);	1✔
209	}
210
211	/**
212	* @internal
213	* Gets a transaction info
214	* @param transactionId - Transaction id or hash.
215	* @param transactionGroup - Transaction group.
216	* @returns Promise<{response: http.ClientResponse; body: TransactionInfoDTO;}>
217	*/
218	private getTransactionByGroup(transactionId: string, transactionGroup: TransactionGroup): Promise<TransactionInfoDTO> {
219	switch (transactionGroup) {	8✔
220	case TransactionGroup.Confirmed:	8✔
221	return this.transactionRoutesApi.getConfirmedTransaction(transactionId);	6✔
222	case TransactionGroup.Unconfirmed:
223	return this.transactionRoutesApi.getUnconfirmedTransaction(transactionId);	1✔
224	case TransactionGroup.Partial:
225	return this.transactionRoutesApi.getPartialTransaction(transactionId);	1✔
226	}
227	}
228
229	/**
230	* @internal
231	* Gets a transaction search result
232	* @param criteria - the criteria.
233	* @returns Promise<{response: http.ClientResponse; body: TransactionInfoDTO;}>
234	*/
235	private searchTransactionByGroup(criteria: TransactionSearchCriteria): Promise<TransactionPage> {
236	switch (criteria.group) {	3✔
237	case TransactionGroup.Confirmed:	3✔
238	return this.transactionRoutesApi.searchConfirmedTransactions(	1✔
239	criteria.address?.plain(),	3!
240	criteria.recipientAddress?.plain(),	1!
241	criteria.signerPublicKey,	2✔
242	criteria.height?.toString(),	3!
243	criteria.fromHeight?.toString(),	3!
244	criteria.toHeight?.toString(),	3!
245	criteria.fromTransferAmount?.toString(),	3!
246	criteria.toTransferAmount?.toString(),	3!
247	criteria.type?.map((type) => type.valueOf()),	×
248	criteria.embedded,	2✔
249	criteria.transferMosaicId?.toHex(),	1!
250	criteria.pageSize,
251	criteria.pageNumber,
252	criteria.offset,
253	DtoMapping.mapEnum(criteria.order),
254	);
255	case TransactionGroup.Unconfirmed:
256	return this.transactionRoutesApi.searchUnconfirmedTransactions(	1✔
257	criteria.address?.plain(),	3!
258	criteria.recipientAddress?.plain(),	1!
259	criteria.signerPublicKey,	2✔
260	criteria.height?.toString(),	3!
261	criteria.fromHeight?.toString(),	3!
262	criteria.toHeight?.toString(),	3!
263	criteria.fromTransferAmount?.toString(),	3!
264	criteria.toTransferAmount?.toString(),	3!
265	criteria.type?.map((type) => type.valueOf()),	×
266	criteria.embedded,	2✔
267	criteria.transferMosaicId?.toHex(),	1!
268	criteria.pageSize,
269	criteria.pageNumber,
270	criteria.offset,
271	DtoMapping.mapEnum(criteria.order),
272	);
273	case TransactionGroup.Partial:
274	return this.transactionRoutesApi.searchPartialTransactions(	1✔
275	criteria.address?.plain(),	3!
276	criteria.recipientAddress?.plain(),	1!
277	criteria.signerPublicKey,	2✔
278	criteria.height?.toString(),	3!
279	criteria.fromHeight?.toString(),	3!
280	criteria.toHeight?.toString(),	3!
281	criteria.fromTransferAmount?.toString(),	3!
282	criteria.toTransferAmount?.toString(),	3!
283	criteria.type?.map((type) => type.valueOf()),	×
284	criteria.embedded,	2✔
285	criteria.transferMosaicId?.toHex(),	1!
286	criteria.pageSize,
287	criteria.pageNumber,
288	criteria.offset,
289	DtoMapping.mapEnum(criteria.order),
290	);
291	}
292	}
293	}

nemtech / symbol-sdk-typescript-javascript / 1989

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