10217298703

Committed 02 Aug 2024 02:29PM UTC coverage: 93.715% (-0.04%) from 93.757%

Build # 10217298703

Build Type

push

github

Committed by

web-flow

Commit Message

Feat: Add EtherPortal Specification (#224)

Run Details

1146 of 1363 branches covered (84.08%)

Branch coverage included in aggregate %.

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

15 existing lines in 1 file now uncovered.

12394 of 13085 relevant lines covered (94.72%)

46.77 hits per line

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

87.85

/apps/web/src/components/inputs/inputDetailsView.tsx

"use client";
import { InputDetails } from "@cartesi/rollups-explorer-ui";
import { Alert, Box, Group, Select, Stack, Text } from "@mantine/core";
import { find, omit, pathOr } from "ramda";
import { included, isNilOrEmpty, isNotNilOrEmpty } from "ramda-adjunct";
import { FC, useEffect, useState } from "react";
import { TbExclamationCircle } from "react-icons/tb";
import { useQuery } from "urql";
import { Address, Hex } from "viem";
import { InputItemFragment } from "../../graphql/explorer/operations";
import {
    InputDetailsDocument,
    InputDetailsQuery,
    InputDetailsQueryVariables,
} from "../../graphql/rollups/operations";
import { Voucher } from "../../graphql/rollups/types";
import { useConnectionConfig } from "../../providers/connectionConfig/hooks";
import { theme } from "../../providers/theme";
import { NewSpecificationButton } from "../specification/components/NewSpecificationButton";
import { findSpecificationFor } from "../specification/conditionals";
import { Envelope, decodePayload } from "../specification/decoder";
import { useSpecification } from "../specification/hooks/useSpecification";
import { useSystemSpecifications } from "../specification/hooks/useSystemSpecifications";
import { Specification } from "../specification/types";
import { stringifyContent } from "../specification/utils";
import VoucherExecution from "./voucherExecution";

interface ApplicationInputDataProps {
    input: InputItemFragment;
}

type InputTypes = "vouchers" | "reports" | "notices";

const payloadOrString = pathOr("", ["edges", 0, "node", "payload"]);

const updateForNextPage = (
    name: InputTypes,
    obj: InputDetailsQueryVariables,
) => {
    switch (name) {
        case "vouchers":
            return omit(["lastVouchers", "vouchersPrevPage"], obj);
        case "notices":
            return omit(["lastNotices", "noticesPrevPage"], obj);
        case "reports":
            return omit(["lastReports", "reportsPrevPage"], obj);
        default:
            throw new Error(`${name} not supported.`);
    }
};

const updateForPrevPage = (
    name: InputTypes,
    obj: InputDetailsQueryVariables,
) => {
    switch (name) {
        case "vouchers":
            return omit(["firstVouchers", "vouchersNextPage"], obj);
        case "notices":
            return omit(["firstNotices", "noticesNextPage"], obj);
        case "reports":
            return omit(["firstReports", "reportsNextPage"], obj);
        default:
            throw new Error(`${name} not supported.`);
    }
};

const getStringifiedDecodedValueOrPayload = (
    envelope: Envelope | undefined,
    originalPayload: string,
) => {
    if (envelope?.error) {
        console.error(envelope.error);
        return originalPayload;
    }

    if (!envelope || isNilOrEmpty(envelope?.result)) {
        return originalPayload;
    }

    return stringifyContent(envelope.result);
};

type UseDecodingOnInputResult = [
    string,
    {
        specApplied: Specification | null;
        userSpecifications: Specification[];
        systemSpecifications: Specification[];
        error?: Error;
        wasSpecManuallySelected: boolean;
    },
];

/**
 * Receive the input from a graphQL call and
 * It may find a specification that matches a defined condition, therefore decoding the content.
 * If an specification is not found it returns the original payload.
 * @param input Input data returned by graphQL.
 * @param specName Specification id to apply instead of check for matching conditions. (optional)
 * @returns { UseDecodingOnInputResult }
 */
const useDecodingOnInput = (
    input: InputItemFragment,
    specId?: string,
): UseDecodingOnInputResult => {
    const { listSpecifications } = useSpecification();
    const { systemSpecificationAsList } = useSystemSpecifications();

    const userSpecifications = listSpecifications() ?? [];
    const specifications = [
        ...systemSpecificationAsList,
        ...userSpecifications,
    ];

    const specification = isNilOrEmpty(specId)
        ? findSpecificationFor(input, specifications)
        : find((spec) => spec.id === specId, specifications) ?? null;

    const envelope = specification
        ? decodePayload(specification, input.payload as Hex)
        : undefined;

    const result = getStringifiedDecodedValueOrPayload(envelope, input.payload);

    return [
        result,
        {
            specApplied: specification,
            systemSpecifications: systemSpecificationAsList,
            userSpecifications,
            error: envelope?.error,
            wasSpecManuallySelected: isNotNilOrEmpty(specId),
        },
    ];
};

const buildSelectData = (
    userSpecifications: Specification[],
    systemSpecifications: Specification[],
) => {
    const groups = [];

    if (userSpecifications.length) {
        groups.push({
            group: "Your Specifications",
            items: userSpecifications.map((spec) => ({
                label: spec.name,
                value: spec.id!,
            })),
        });
    }

    if (systemSpecifications.length) {
        groups.push({
            group: "System Specifications",
            items: systemSpecifications.map((spec) => ({
                label: spec.name,
                value: spec.id!,
            })),
        });
    }

    return groups;
};

/**
 * InputDetailsView should be lazy rendered.
 * to avoid multiple eager network calls.
 */
const InputDetailsView: FC<ApplicationInputDataProps> = ({ input }) => {
    const { getConnection, hasConnection, showConnectionModal } =
        useConnectionConfig();
    const appId = input.application.id as Address;
    const inputIdx = input.index;
    const connection = getConnection(appId);
    const [selectedSpec, setSelectedSpec] = useState<string>("");
    const [variables, updateQueryVars] = useState<InputDetailsQueryVariables>({
        firstNotices: 1,
        firstReports: 1,
        firstVouchers: 1,
        inputIdx,
    });

    const [result, execQuery] = useQuery<
        InputDetailsQuery,
        InputDetailsQueryVariables
    >({
        query: InputDetailsDocument,
        pause: true,
        variables,
    });

    const reports = result.data?.input.reports;
    const notices = result.data?.input.notices;
    const vouchers = result.data?.input.vouchers;

    const showNotices =
        !connection ||
        (connection && notices && payloadOrString(notices) !== "");
    const showReports =
        !connection ||
        (connection && reports && payloadOrString(reports) !== "");
    const showVouchers =
        !connection ||
        (connection && vouchers && payloadOrString(vouchers) !== "");
    const vouchersForExecution = (vouchers?.edges?.map((e) => e.node) ??
        []) as Partial<Voucher>[];
    const showVoucherForExecution =
        showVouchers && vouchersForExecution.length > 0;

    const [
        inputContent,
        {
            specApplied,
            error,
            systemSpecifications,
            userSpecifications,
            wasSpecManuallySelected,
        },
    ] = useDecodingOnInput(input, selectedSpec);

    const selectData = buildSelectData(
        userSpecifications,
        systemSpecifications,
    );

    useEffect(() => {
        if (connection) execQuery({ url: connection.url });
    }, [connection, execQuery, variables]);

    const isSystemSpecAppliedManually =
        wasSpecManuallySelected && included(systemSpecifications, specApplied);

    return (
        <Box py="md">
            <InputDetails>
                <InputDetails.InputContent
                    content={inputContent}
                    contentType="raw"
                >
                    <Stack gap="sm">
                        <Group>
                            <Select
                                label="Decode Specification"
                                description="When a specification condition(s) match(es), it will be auto-selected."
                                placeholder="Decode content with..."
                                value={specApplied?.id ?? selectedSpec}
                                size="md"
                                checkIconPosition="right"
                                data={selectData}
                                onChange={(value) => {
                                    setSelectedSpec(value ?? "");
                                }}
                                error={
                                    error
                                        ? `We're not able to decode using ${specApplied?.name}`
                                        : null
                                }
                            />
                        </Group>
                        {isSystemSpecAppliedManually && (
                            <Group>
                                <Alert
                                    data-testid="system-spec-applied-warning"
                                    icon={
                                        <TbExclamationCircle
                                            size={theme.other.iconSize}
                                        />
                                    }
                                    color="orange"
                                    title="System Specifications"
                                >
                                    Be careful when manually selecting system
                                    specifications.
                                    <br /> It may show readable information by
                                    sheer luck of byte length.
                                    <br /> They are always auto-selected.
                                </Alert>
                            </Group>
                        )}

                        {!specApplied && (
                            <Group gap={3}>
                                <Text c="dimmed">
                                    {`Is this Application ABI encoding it's inputs?`}
                                </Text>
                                <NewSpecificationButton
                                    p={0}
                                    variant="transparent"
                                    btnText="Add a Spec!"
                                />
                            </Group>
                        )}
                    </Stack>
                </InputDetails.InputContent>

                {showReports && (
                    <InputDetails.ReportContent
                        content={payloadOrString(reports)}
                        contentType="raw"
                        onConnect={() => showConnectionModal(appId)}
                        isLoading={result.fetching}
                        isConnected={hasConnection(appId)}
                        paging={{
                            total: reports?.totalCount ?? 0,
                            onNextPage: () => {
                                updateQueryVars((vars) => {
                                    const newVars = {
                                        ...vars,
                                        firstReports: 1,
                                        reportsNextPage:
                                            reports?.pageInfo.endCursor,
                                    };

                                    return updateForNextPage(
                                        "reports",
                                        newVars,
                                    );
                                });
                            },
                            onPreviousPage: () => {
                                updateQueryVars((vars) => {
                                    const newVars = {
                                        ...vars,
                                        lastReports: 1,
                                        reportsPrevPage:
                                            reports?.pageInfo.startCursor,
                                    };
                                    return updateForPrevPage(
                                        "reports",
                                        newVars,
                                    );
                                });
                            },
                        }}
                    />
                )}

                {showNotices && (
                    <InputDetails.NoticeContent
                        content={payloadOrString(notices)}
                        contentType="raw"
                        onConnect={() => showConnectionModal(appId)}
                        isLoading={result.fetching}
                        isConnected={hasConnection(appId)}
                        paging={{
                            total: notices?.totalCount ?? 0,
                            onNextPage: () => {
                                updateQueryVars((vars) => {
                                    const newVars = {
                                        ...vars,
                                        firstNotices: 1,
                                        noticesNextPage:
                                            notices?.pageInfo.endCursor,
                                    };
                                    return updateForNextPage(
                                        "notices",
                                        newVars,
                                    );
                                });
                            },
                            onPreviousPage: () => {
                                updateQueryVars((vars) => {
                                    const newVars = {
                                        ...vars,
                                        lastNotices: 1,
                                        noticesPrevPage:
                                            notices?.pageInfo.startCursor,
                                    };

                                    return updateForPrevPage(
                                        "notices",
                                        newVars,
                                    );
                                });
                            },
                        }}
                    />
                )}

                {showVouchers && (
                    <InputDetails.VoucherContent
                        content={payloadOrString(vouchers)}
                        contentType="raw"
                        onConnect={() => showConnectionModal(appId)}
                        isLoading={result.fetching}
                        isConnected={hasConnection(appId)}
                        paging={{
                            total: vouchers?.totalCount ?? 0,
                            onNextPage: () => {
                                updateQueryVars((vars) => {
                                    const newVars = {
                                        ...vars,
                                        firstVouchers: 1,
                                        vouchersNextPage:
                                            vouchers?.pageInfo.endCursor,
                                    };

                                    return updateForNextPage(
                                        "vouchers",
                                        newVars,
                                    );
                                });
                            },
                            onPreviousPage: () => {
                                updateQueryVars((vars) => {
                                    const newVars = {
                                        ...vars,
                                        lastVouchers: 1,
                                        vouchersPrevPage:
                                            vouchers?.pageInfo.startCursor,
                                    };

                                    return updateForPrevPage(
                                        "vouchers",
                                        newVars,
                                    );
                                });
                            },
                        }}
                    >
                        {showVoucherForExecution ? (
                            <VoucherExecution
                                appId={appId}
                                voucher={vouchersForExecution[0]}
                            />
                        ) : null}
                    </InputDetails.VoucherContent>
                )}
            </InputDetails>
        </Box>
    );
};

export default InputDetailsView;

1	"use client";	1✔
2	import { InputDetails } from "@cartesi/rollups-explorer-ui";	1✔
3	import { Alert, Box, Group, Select, Stack, Text } from "@mantine/core";	1✔
4	import { find, omit, pathOr } from "ramda";	1✔
5	import { included, isNilOrEmpty, isNotNilOrEmpty } from "ramda-adjunct";	1✔
6	import { FC, useEffect, useState } from "react";	1✔
7	import { TbExclamationCircle } from "react-icons/tb";	1✔
8	import { useQuery } from "urql";	1✔
9	import { Address, Hex } from "viem";	1✔
10	import { InputItemFragment } from "../../graphql/explorer/operations";	1✔
11	import {	1✔
12	InputDetailsDocument,	1✔
13	InputDetailsQuery,	1✔
14	InputDetailsQueryVariables,	1✔
15	} from "../../graphql/rollups/operations";	1✔
16	import { Voucher } from "../../graphql/rollups/types";	1✔
17	import { useConnectionConfig } from "../../providers/connectionConfig/hooks";	1✔
18	import { theme } from "../../providers/theme";	1✔
19	import { NewSpecificationButton } from "../specification/components/NewSpecificationButton";	1✔
20	import { findSpecificationFor } from "../specification/conditionals";	1✔
21	import { Envelope, decodePayload } from "../specification/decoder";	1✔
22	import { useSpecification } from "../specification/hooks/useSpecification";	1✔
23	import { useSystemSpecifications } from "../specification/hooks/useSystemSpecifications";	1✔
24	import { Specification } from "../specification/types";	1✔
25	import { stringifyContent } from "../specification/utils";	1✔
26	import VoucherExecution from "./voucherExecution";	1✔
27		1✔
28	interface ApplicationInputDataProps {	1✔
29	input: InputItemFragment;	1✔
30	}	1✔
31		1✔
32	type InputTypes = "vouchers" \| "reports" \| "notices";	1✔
33		1✔
34	const payloadOrString = pathOr("", ["edges", 0, "node", "payload"]);	1✔
35		1✔
36	const updateForNextPage = (	1✔
37	name: InputTypes,	3✔
38	obj: InputDetailsQueryVariables,	3✔
39	) => {	3✔
40	switch (name) {	3✔
41	case "vouchers":	3✔
42	return omit(["lastVouchers", "vouchersPrevPage"], obj);	1✔
43	case "notices":	3✔
44	return omit(["lastNotices", "noticesPrevPage"], obj);	1✔
45	case "reports":	3✔
46	return omit(["lastReports", "reportsPrevPage"], obj);	1✔
47	default:	3!
48	throw new Error(`${name} not supported.`);	×
49	}	3✔
50	};	3✔
51		1✔
52	const updateForPrevPage = (	1✔
53	name: InputTypes,	3✔
54	obj: InputDetailsQueryVariables,	3✔
55	) => {	3✔
56	switch (name) {	3✔
57	case "vouchers":	3✔
58	return omit(["firstVouchers", "vouchersNextPage"], obj);	1✔
59	case "notices":	3✔
60	return omit(["firstNotices", "noticesNextPage"], obj);	1✔
61	case "reports":	3✔
62	return omit(["firstReports", "reportsNextPage"], obj);	1✔
63	default:	3!
64	throw new Error(`${name} not supported.`);	×
65	}	3✔
66	};	3✔
67		1✔
68	const getStringifiedDecodedValueOrPayload = (	1✔
69	envelope: Envelope \| undefined,	33✔
70	originalPayload: string,	33✔
71	) => {	33✔
72	if (envelope?.error) {	33✔
73	console.error(envelope.error);	33✔
74	return originalPayload;	33✔
75	}	33!
UNCOV 76		×
77	if (!envelope \|\| isNilOrEmpty(envelope?.result)) {	33!
UNCOV 78	return originalPayload;	×
UNCOV 79	}	×
80		×
81	return stringifyContent(envelope.result);	×
82	};	×
83		1✔
84	type UseDecodingOnInputResult = [	1✔
85	string,	1✔
86	{	1✔
87	specApplied: Specification \| null;	1✔
88	userSpecifications: Specification[];	1✔
89	systemSpecifications: Specification[];	1✔
90	error?: Error;	1✔
91	wasSpecManuallySelected: boolean;	1✔
92	},	1✔
93	];	1✔
94		1✔
95	/**	1✔
96	* Receive the input from a graphQL call and	1✔
97	* It may find a specification that matches a defined condition, therefore decoding the content.	1✔
98	* If an specification is not found it returns the original payload.	1✔
99	* @param input Input data returned by graphQL.	1✔
100	* @param specName Specification id to apply instead of check for matching conditions. (optional)	1✔
101	* @returns { UseDecodingOnInputResult }	1✔
102	*/	1✔
103	const useDecodingOnInput = (	1✔
104	input: InputItemFragment,	33✔
105	specId?: string,	33✔
106	): UseDecodingOnInputResult => {	33✔
107	const { listSpecifications } = useSpecification();	33✔
108	const { systemSpecificationAsList } = useSystemSpecifications();	33✔
109		33✔
110	const userSpecifications = listSpecifications() ?? [];	33✔
111	const specifications = [	33✔
112	...systemSpecificationAsList,	33✔
113	...userSpecifications,	33✔
114	];	33✔
115		33✔
116	const specification = isNilOrEmpty(specId)	33✔
117	? findSpecificationFor(input, specifications)	33!
118	: find((spec) => spec.id === specId, specifications) ?? null;	×
119		33✔
120	const envelope = specification	33✔
121	? decodePayload(specification, input.payload as Hex)	33!
UNCOV 122	: undefined;	×
123		33✔
124	const result = getStringifiedDecodedValueOrPayload(envelope, input.payload);	33✔
125		33✔
126	return [	33✔
127	result,	33✔
128	{	33✔
129	specApplied: specification,	33✔
130	systemSpecifications: systemSpecificationAsList,	33✔
131	userSpecifications,	33✔
132	error: envelope?.error,	33✔
133	wasSpecManuallySelected: isNotNilOrEmpty(specId),	33✔
134	},	33✔
135	];	33✔
136	};	33✔
137		1✔
138	const buildSelectData = (	1✔
139	userSpecifications: Specification[],	33✔
140	systemSpecifications: Specification[],	33✔
141	) => {	33✔
142	const groups = [];	33✔
143		33✔
144	if (userSpecifications.length) {	33!
145	groups.push({	×
146	group: "Your Specifications",	×
147	items: userSpecifications.map((spec) => ({	×
148	label: spec.name,	×
149	value: spec.id!,	×
150	})),	×
151	});	×
152	}	×
153		33✔
154	if (systemSpecifications.length) {	33✔
155	groups.push({	33✔
156	group: "System Specifications",	33✔
157	items: systemSpecifications.map((spec) => ({	33✔
158	label: spec.name,	198✔
159	value: spec.id!,	198✔
160	})),	33✔
161	});	33✔
162	}	33✔
163		33✔
164	return groups;	33✔
165	};	33✔
166		1✔
167	/**	1✔
168	* InputDetailsView should be lazy rendered.	1✔
169	* to avoid multiple eager network calls.	1✔
170	*/	1✔
171	const InputDetailsView: FC<ApplicationInputDataProps> = ({ input }) => {	1✔
172	const { getConnection, hasConnection, showConnectionModal } =	34✔
173	useConnectionConfig();	34✔
174	const appId = input.application.id as Address;	34✔
175	const inputIdx = input.index;	34✔
176	const connection = getConnection(appId);	34✔
177	const [selectedSpec, setSelectedSpec] = useState<string>("");	34✔
178	const [variables, updateQueryVars] = useState<InputDetailsQueryVariables>({	34✔
179	firstNotices: 1,	34✔
180	firstReports: 1,	34✔
181	firstVouchers: 1,	34✔
182	inputIdx,	34✔
183	});	34✔
184		34✔
185	const [result, execQuery] = useQuery<	34✔
186	InputDetailsQuery,	34✔
187	InputDetailsQueryVariables	34✔
188	>({	34✔
189	query: InputDetailsDocument,	34✔
190	pause: true,	34✔
191	variables,	34✔
192	});	34✔
193		34✔
194	const reports = result.data?.input.reports;	34✔
195	const notices = result.data?.input.notices;	34✔
196	const vouchers = result.data?.input.vouchers;	34✔
197		34✔
198	const showNotices =	34✔
199	!connection \|\|	34✔
200	(connection && notices && payloadOrString(notices) !== "");	19✔
201	const showReports =	34✔
202	!connection \|\|	34✔
203	(connection && reports && payloadOrString(reports) !== "");	19✔
204	const showVouchers =	34✔
205	!connection \|\|	34✔
206	(connection && vouchers && payloadOrString(vouchers) !== "");	19✔
207	const vouchersForExecution = (vouchers?.edges?.map((e) => e.node) ??	34✔
208	[]) as Partial<Voucher>[];	14✔
209	const showVoucherForExecution =	34✔
210	showVouchers && vouchersForExecution.length > 0;	34✔
211		34✔
212	const [	34✔
213	inputContent,	34✔
214	{	34✔
215	specApplied,	34✔
216	error,	34✔
217	systemSpecifications,	34✔
218	userSpecifications,	34✔
219	wasSpecManuallySelected,	34✔
220	},	34✔
221	] = useDecodingOnInput(input, selectedSpec);	34✔
222		34✔
223	const selectData = buildSelectData(	34✔
224	userSpecifications,	34✔
225	systemSpecifications,	34✔
226	);	34✔
227		34✔
228	useEffect(() => {	34✔
229	if (connection) execQuery({ url: connection.url });	21✔
230	}, [connection, execQuery, variables]);	34✔
231		34✔
232	const isSystemSpecAppliedManually =	34✔
233	wasSpecManuallySelected && included(systemSpecifications, specApplied);	34!
234		34✔
235	return (	34✔
236	<Box py="md">	34✔
237	<InputDetails>	34✔
238	<InputDetails.InputContent	34✔
239	content={inputContent}	34✔
240	contentType="raw"	34✔
241	>	34✔
242	<Stack gap="sm">	34✔
243	<Group>	34✔
244	<Select	34✔
245	label="Decode Specification"	34✔
246	description="When a specification condition(s) match(es), it will be auto-selected."	34✔
247	placeholder="Decode content with..."	34✔
248	value={specApplied?.id ?? selectedSpec}	34!
249	size="md"	34✔
250	checkIconPosition="right"	34✔
251	data={selectData}	34✔
252	onChange={(value) => {	34✔
253	setSelectedSpec(value ?? "");	×
254	}}	×
255	error={	34✔
256	error	34✔
257	? `We're not able to decode using ${specApplied?.name}`	33!
UNCOV 258	: null	×
259	}	34✔
260	/>	34✔
261	</Group>	34✔
262	{isSystemSpecAppliedManually && (	34!
263	<Group>	×
264	<Alert	×
265	data-testid="system-spec-applied-warning"	×
266	icon={	×
267	<TbExclamationCircle	×
268	size={theme.other.iconSize}	×
269	/>	×
270	}	×
271	color="orange"	×
272	title="System Specifications"	×
273	>	×
274	Be careful when manually selecting system	×
275	specifications.	×
276	<br /> It may show readable information by	×
277	sheer luck of byte length.	×
278	<br /> They are always auto-selected.	×
279	</Alert>	×
280	</Group>	×
281	)}	34✔
282		34✔
283	{!specApplied && (	34!
UNCOV 284	<Group gap={3}>	×
UNCOV 285	<Text c="dimmed">	×
UNCOV 286	{`Is this Application ABI encoding it's inputs?`}	×
UNCOV 287	</Text>	×
UNCOV 288	<NewSpecificationButton	×
UNCOV 289	p={0}	×
UNCOV 290	variant="transparent"	×
UNCOV 291	btnText="Add a Spec!"	×
UNCOV 292	/>	×
UNCOV 293	</Group>	×
294	)}	34✔
295	</Stack>	34✔
296	</InputDetails.InputContent>	34✔
297		34✔
298	{showReports && (	34✔
299	<InputDetails.ReportContent	33✔
300	content={payloadOrString(reports)}	33✔
301	contentType="raw"	33✔
302	onConnect={() => showConnectionModal(appId)}	33✔
303	isLoading={result.fetching}	33✔
304	isConnected={hasConnection(appId)}	33✔
305	paging={{	33✔
306	total: reports?.totalCount ?? 0,	33✔
307	onNextPage: () => {	33✔
308	updateQueryVars((vars) => {	1✔
309	const newVars = {	1✔
310	...vars,	1✔
311	firstReports: 1,	1✔
312	reportsNextPage:	1✔
313	reports?.pageInfo.endCursor,	1✔
314	};	1✔
315		1✔
316	return updateForNextPage(	1✔
317	"reports",	1✔
318	newVars,	1✔
319	);	1✔
320	});	1✔
321	},	1✔
322	onPreviousPage: () => {	33✔
323	updateQueryVars((vars) => {	1✔
324	const newVars = {	1✔
325	...vars,	1✔
326	lastReports: 1,	1✔
327	reportsPrevPage:	1✔
328	reports?.pageInfo.startCursor,	1✔
329	};	1✔
330	return updateForPrevPage(	1✔
331	"reports",	1✔
332	newVars,	1✔
333	);	1✔
334	});	1✔
335	},	1✔
336	}}	33✔
337	/>	33✔
338	)}	34✔
339		34✔
340	{showNotices && (	34✔
341	<InputDetails.NoticeContent	28✔
342	content={payloadOrString(notices)}	28✔
343	contentType="raw"	28✔
344	onConnect={() => showConnectionModal(appId)}	28✔
345	isLoading={result.fetching}	28✔
346	isConnected={hasConnection(appId)}	28✔
347	paging={{	28✔
348	total: notices?.totalCount ?? 0,	28✔
349	onNextPage: () => {	28✔
350	updateQueryVars((vars) => {	1✔
351	const newVars = {	1✔
352	...vars,	1✔
353	firstNotices: 1,	1✔
354	noticesNextPage:	1✔
355	notices?.pageInfo.endCursor,	1✔
356	};	1✔
357	return updateForNextPage(	1✔
358	"notices",	1✔
359	newVars,	1✔
360	);	1✔
361	});	1✔
362	},	1✔
363	onPreviousPage: () => {	28✔
364	updateQueryVars((vars) => {	1✔
365	const newVars = {	1✔
366	...vars,	1✔
367	lastNotices: 1,	1✔
368	noticesPrevPage:	1✔
369	notices?.pageInfo.startCursor,	1✔
370	};	1✔
371		1✔
372	return updateForPrevPage(	1✔
373	"notices",	1✔
374	newVars,	1✔
375	);	1✔
376	});	1✔
377	},	1✔
378	}}	28✔
379	/>	28✔
380	)}	34✔
381		34✔
382	{showVouchers && (	34✔
383	<InputDetails.VoucherContent	28✔
384	content={payloadOrString(vouchers)}	28✔
385	contentType="raw"	28✔
386	onConnect={() => showConnectionModal(appId)}	28✔
387	isLoading={result.fetching}	28✔
388	isConnected={hasConnection(appId)}	28✔
389	paging={{	28✔
390	total: vouchers?.totalCount ?? 0,	28✔
391	onNextPage: () => {	28✔
392	updateQueryVars((vars) => {	1✔
393	const newVars = {	1✔
394	...vars,	1✔
395	firstVouchers: 1,	1✔
396	vouchersNextPage:	1✔
397	vouchers?.pageInfo.endCursor,	1✔
398	};	1✔
399		1✔
400	return updateForNextPage(	1✔
401	"vouchers",	1✔
402	newVars,	1✔
403	);	1✔
404	});	1✔
405	},	1✔
406	onPreviousPage: () => {	28✔
407	updateQueryVars((vars) => {	1✔
408	const newVars = {	1✔
409	...vars,	1✔
410	lastVouchers: 1,	1✔
411	vouchersPrevPage:	1✔
412	vouchers?.pageInfo.startCursor,	1✔
413	};	1✔
414		1✔
415	return updateForPrevPage(	1✔
416	"vouchers",	1✔
417	newVars,	1✔
418	);	1✔
419	});	1✔
420	},	1✔
421	}}	28✔
422	>	28✔
423	{showVoucherForExecution ? (	28✔
424	<VoucherExecution	14✔
425	appId={appId}	14✔
426	voucher={vouchersForExecution[0]}	14✔
427	/>	14✔
428	) : null}	14✔
429	</InputDetails.VoucherContent>	28✔
430	)}	34✔
431	</InputDetails>	34✔
432	</Box>	34✔
433	);	34✔
434	};	34✔
435		1✔
436	export default InputDetailsView;	1✔

cartesi / rollups-explorer / 10217298703

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