@mantleio/viem 0.0.1-alpha.0

package/src/mantle/actions/getWithdrawalStatus.ts

@@ -0,0 +1,225 @@
+import type {
+	Account,
+	Chain,
+	Client,
+	DeriveChain,
+	GetChainParameter,
+	Transport,
+} from "viem";
+import { ContractFunctionRevertedError } from "viem";
+import { readContract, type ReadContractErrorType } from "viem/actions";
+import type { ErrorType } from "../errors/utils.js";
+
+import type { TransactionReceipt } from "viem";
+import type { OneOf } from "viem";
+import { portal2Abi, portalAbi } from "../abis.js";
+import {
+	ReceiptContainsNoWithdrawalsError,
+	type ReceiptContainsNoWithdrawalsErrorType,
+} from "../errors/withdrawal.js";
+import type { TargetChain } from "../types/chain.js";
+import type { GetContractAddressParameter } from "../types/contract.js";
+import {
+	getWithdrawals,
+	type GetWithdrawalsErrorType,
+} from "../utils/getWithdrawals.js";
+import {
+	getL2Output,
+	type GetL2OutputErrorType,
+	type GetL2OutputParameters,
+} from "./getL2Output.js";
+import {
+	getPortalVersion,
+	type GetPortalVersionParameters,
+} from "./getPortalVersion.js";
+import {
+	getTimeToFinalize,
+	type GetTimeToFinalizeErrorType,
+	type GetTimeToFinalizeParameters,
+} from "./getTimeToFinalize.js";
+
+export type GetWithdrawalStatusParameters<
+	chain extends Chain | undefined = Chain | undefined,
+	chainOverride extends Chain | undefined = Chain | undefined,
+	_derivedChain extends Chain | undefined = DeriveChain<chain, chainOverride>,
+> = GetChainParameter<chain, chainOverride> &
+	OneOf<
+		GetContractAddressParameter<_derivedChain, "l2OutputOracle" | "portal">
+	> & {
+		receipt: TransactionReceipt;
+	};
+export type GetWithdrawalStatusReturnType =
+	| "waiting-to-prove"
+	| "ready-to-prove"
+	| "waiting-to-finalize"
+	| "ready-to-finalize"
+	| "finalized";
+
+export type GetWithdrawalStatusErrorType =
+	| GetL2OutputErrorType
+	| GetTimeToFinalizeErrorType
+	| GetWithdrawalsErrorType
+	| ReadContractErrorType
+	| ReceiptContainsNoWithdrawalsErrorType
+	| ErrorType;
+
+/**
+ * @param client - Client to use
+ * @param parameters - {@link GetWithdrawalStatusParameters}
+ * @returns Status of the withdrawal. {@link GetWithdrawalStatusReturnType}
+ */
+export async function getWithdrawalStatus<
+	chain extends Chain | undefined,
+	account extends Account | undefined,
+	chainOverride extends Chain | undefined = undefined,
+>(
+	client: Client<Transport, chain, account>,
+	parameters: GetWithdrawalStatusParameters<chain, chainOverride>,
+): Promise<GetWithdrawalStatusReturnType> {
+	const {
+		chain = client.chain,
+		receipt,
+		targetChain: targetChain_,
+	} = parameters;
+
+	const targetChain = targetChain_ as unknown as TargetChain;
+
+	const portalAddress = (() => {
+		if (parameters.portalAddress) return parameters.portalAddress;
+		if (chain) return targetChain.contracts.portal[chain.id].address;
+		return Object.values(targetChain.contracts.portal)[0].address;
+	})();
+
+	const [withdrawal] = getWithdrawals(receipt);
+
+	if (!withdrawal) {
+		throw new ReceiptContainsNoWithdrawalsError({
+			hash: receipt.transactionHash,
+		});
+	}
+
+	const portalVersion = await getPortalVersion(
+		client,
+		parameters as GetPortalVersionParameters,
+	);
+
+	// Legacy (Portal < v3)
+	if (portalVersion.major < 3) {
+		const [outputResult, proveResult, finalizedResult, timeToFinalizeResult] =
+			await Promise.allSettled([
+				getL2Output(client, {
+					...parameters,
+					l2BlockNumber: receipt.blockNumber,
+				} as GetL2OutputParameters),
+				readContract(client, {
+					abi: portalAbi,
+					address: portalAddress,
+					functionName: "provenWithdrawals",
+					args: [withdrawal.withdrawalHash],
+				}),
+				readContract(client, {
+					abi: portalAbi,
+					address: portalAddress,
+					functionName: "finalizedWithdrawals",
+					args: [withdrawal.withdrawalHash],
+				}),
+				getTimeToFinalize(client, {
+					...parameters,
+					withdrawalHash: withdrawal.withdrawalHash,
+				} as GetTimeToFinalizeParameters),
+			]);
+
+		// If the L2 Output is not processed yet (ie. the actions throws), this means
+		// that the withdrawal is not ready to prove.
+		if (outputResult.status === "rejected") {
+			const error = outputResult.reason as GetL2OutputErrorType;
+			if (
+				error.cause instanceof ContractFunctionRevertedError &&
+				error.cause.data?.args?.[0] ===
+					"L2OutputOracle: cannot get output for a block that has not been proposed"
+			) {
+				return "waiting-to-prove";
+			}
+			throw error;
+		}
+		if (proveResult.status === "rejected") throw proveResult.reason;
+		if (finalizedResult.status === "rejected") throw finalizedResult.reason;
+		if (timeToFinalizeResult.status === "rejected") {
+			throw timeToFinalizeResult.reason;
+		}
+
+		const [_, proveTimestamp] = proveResult.value;
+		if (!proveTimestamp) return "ready-to-prove";
+
+		const finalized = finalizedResult.value;
+		if (finalized) return "finalized";
+
+		const { seconds } = timeToFinalizeResult.value;
+		return seconds > 0 ? "waiting-to-finalize" : "ready-to-finalize";
+	}
+
+	const numProofSubmitters = await readContract(client, {
+		abi: portal2Abi,
+		address: portalAddress,
+		functionName: "numProofSubmitters",
+		args: [withdrawal.withdrawalHash],
+	}).catch(() => 1n);
+
+	const proofSubmitter = await readContract(client, {
+		abi: portal2Abi,
+		address: portalAddress,
+		functionName: "proofSubmitters",
+		args: [withdrawal.withdrawalHash, numProofSubmitters - 1n],
+	}).catch(() => withdrawal.sender);
+
+	const [checkWithdrawalResult, finalizedResult] = await Promise.allSettled([
+		readContract(client, {
+			abi: portal2Abi,
+			address: portalAddress,
+			functionName: "checkWithdrawal",
+			args: [withdrawal.withdrawalHash, proofSubmitter],
+		}),
+		readContract(client, {
+			abi: portal2Abi,
+			address: portalAddress,
+			functionName: "finalizedWithdrawals",
+			args: [withdrawal.withdrawalHash],
+		}),
+	]);
+
+	if (finalizedResult.status === "fulfilled" && finalizedResult.value) {
+		return "finalized";
+	}
+
+	if (checkWithdrawalResult.status === "rejected") {
+		const error = checkWithdrawalResult.reason as ReadContractErrorType;
+		if (error.cause instanceof ContractFunctionRevertedError) {
+			const errorMessage = error.cause.data?.args?.[0];
+			if (
+				errorMessage === "OptimismPortal: invalid game type" ||
+				errorMessage === "OptimismPortal: withdrawal has not been proven yet" ||
+				errorMessage ===
+					"OptimismPortal: withdrawal has not been proven by proof submitter address yet"
+			) {
+				return "ready-to-prove";
+			}
+			if (
+				errorMessage ===
+					"OptimismPortal: proven withdrawal has not matured yet" ||
+				errorMessage ===
+					"OptimismPortal: output proposal has not been finalized yet" ||
+				errorMessage === "OptimismPortal: output proposal in air-gap"
+			) {
+				return "waiting-to-finalize";
+			}
+
+			if (error.cause.data?.errorName === "InvalidGameType") {
+				return "ready-to-prove";
+			}
+		}
+		throw checkWithdrawalResult.reason;
+	}
+	if (finalizedResult.status === "rejected") throw finalizedResult.reason;
+
+	return "ready-to-finalize";
+}

package/src/mantle/actions/initiateERC20Withdrawal.ts

@@ -0,0 +1,93 @@
+import type { Address } from "viem";
+import type { Client, FormattedTransactionRequest, Transport } from "viem";
+import type { Account } from "viem";
+import type { Chain, DeriveChain, GetChainParameter } from "viem";
+import type { Hash } from "viem";
+import type { UnionEvaluate, UnionOmit } from "viem";
+import {
+	writeContract,
+	type WriteContractErrorType,
+	type WriteContractParameters,
+} from "viem/actions";
+import { l2StandardBridge } from "../abis.js";
+import { contracts } from "../contracts.js";
+import type { ErrorType } from "../errors/utils.js";
+import type { GetAccountParameter } from "../types/account.js";
+import type { InitiateERC20WithdrawalRequest } from "../types/withdrawal.js";
+import { parseInitWithdrawequest } from "../utils/parseInitWithdrawRequest.js";
+
+export type InitiateERC20WithdrawalParameters<
+	chain extends Chain | undefined = Chain | undefined,
+	account extends Account | undefined = Account | undefined,
+	chainOverride extends Chain | undefined = Chain | undefined,
+	_derivedChain extends Chain | undefined = DeriveChain<chain, chainOverride>,
+> = UnionEvaluate<
+	UnionOmit<
+		FormattedTransactionRequest<_derivedChain>,
+		| "accessList"
+		| "data"
+		| "from"
+		| "gas"
+		| "gasPrice"
+		| "to"
+		| "type"
+		| "value"
+	>
+> &
+	GetAccountParameter<account, Account | Address> &
+	GetChainParameter<chain, chainOverride> & {
+		/**
+		 * Gas limit for transaction execution on the L2.
+		 */
+		gas?: bigint | undefined;
+		/** Withdrawal request. Supplied to the L2ToL1MessagePasser `initiateERC20Withdrawal` method. */
+		request: InitiateERC20WithdrawalRequest;
+	};
+export type InitiateERC20WithdrawalReturnType = Hash;
+export type InitiateERC20WithdrawalErrorType =
+	| WriteContractErrorType
+	| ErrorType;
+
+/**
+ * @param client - Client to use
+ * @param parameters - {@link InitiateERC20WithdrawalParameters}
+ * @returns The L2 transaction hash. {@link InitiateERC20WithdrawalReturnType}
+ */
+export async function initiateERC20Withdrawal<
+	chain extends Chain | undefined,
+	account extends Account | undefined,
+	chainOverride extends Chain | undefined = undefined,
+>(
+	client: Client<Transport, chain, account>,
+	parameters: InitiateERC20WithdrawalParameters<chain, account, chainOverride>,
+) {
+	const {
+		account,
+		chain = client.chain,
+		gas,
+		maxFeePerGas,
+		maxPriorityFeePerGas,
+		nonce,
+		request: { amount, to },
+	} = parameters;
+
+	const { functionName, args } = parseInitWithdrawequest({
+		type: "erc20",
+		l2Token: "0x9EF6f9160Ba00B6621e5CB3217BB8b54a92B2828",
+		amount,
+		to,
+	});
+
+	return writeContract(client, {
+		account: account!,
+		abi: l2StandardBridge,
+		address: contracts.l2StandardBridge.address,
+		chain,
+		functionName,
+		args,
+		gas,
+		maxFeePerGas,
+		maxPriorityFeePerGas,
+		nonce,
+	} satisfies WriteContractParameters as any);
+}

package/src/mantle/actions/initiateETHWithdrawal.ts

@@ -0,0 +1,90 @@
+import type { Address } from "viem";
+import type { Client, FormattedTransactionRequest, Transport } from "viem";
+import type { Account } from "viem";
+import type { Chain, DeriveChain, GetChainParameter } from "viem";
+import type { Hash } from "viem";
+import type { UnionEvaluate, UnionOmit } from "viem";
+import {
+	writeContract,
+	type WriteContractErrorType,
+	type WriteContractParameters,
+} from "viem/actions";
+import { l2StandardBridge } from "../abis.js";
+import { contracts } from "../contracts.js";
+import type { ErrorType } from "../errors/utils.js";
+import type { GetAccountParameter } from "../types/account.js";
+import type { InitiateETHWithdrawalRequest } from "../types/withdrawal.js";
+import { parseInitWithdrawequest } from "../utils/parseInitWithdrawRequest.js";
+
+export type InitiateETHWithdrawalParameters<
+	chain extends Chain | undefined = Chain | undefined,
+	account extends Account | undefined = Account | undefined,
+	chainOverride extends Chain | undefined = Chain | undefined,
+	_derivedChain extends Chain | undefined = DeriveChain<chain, chainOverride>,
+> = UnionEvaluate<
+	UnionOmit<
+		FormattedTransactionRequest<_derivedChain>,
+		| "accessList"
+		| "data"
+		| "from"
+		| "gas"
+		| "gasPrice"
+		| "to"
+		| "type"
+		| "value"
+	>
+> &
+	GetAccountParameter<account, Account | Address> &
+	GetChainParameter<chain, chainOverride> & {
+		/**
+		 * Gas limit for transaction execution on the L2.
+		 */
+		gas?: bigint | undefined;
+		/** Withdrawal request. Supplied to the L2ToL1MessagePasser `initiateETHWithdrawal` method. */
+		request: InitiateETHWithdrawalRequest;
+	};
+export type InitiateETHWithdrawalReturnType = Hash;
+export type InitiateETHWithdrawalErrorType = WriteContractErrorType | ErrorType;
+
+/**
+ * @param client - Client to use
+ * @param parameters - {@link InitiateETHWithdrawalParameters}
+ * @returns The L2 transaction hash. {@link InitiateETHWithdrawalReturnType}
+ */
+export async function initiateETHWithdrawal<
+	chain extends Chain | undefined,
+	account extends Account | undefined,
+	chainOverride extends Chain | undefined = undefined,
+>(
+	client: Client<Transport, chain, account>,
+	parameters: InitiateETHWithdrawalParameters<chain, account, chainOverride>,
+) {
+	const {
+		account,
+		chain = client.chain,
+		gas,
+		maxFeePerGas,
+		maxPriorityFeePerGas,
+		nonce,
+		request: { amount, to },
+	} = parameters;
+
+	const { functionName, args } = parseInitWithdrawequest({
+		type: "eth",
+		amount,
+		to,
+	});
+
+	return writeContract(client, {
+		account: account!,
+		abi: l2StandardBridge,
+		address: contracts.l2StandardBridge.address,
+		chain,
+		functionName,
+		args,
+		gas,
+		maxFeePerGas,
+		maxPriorityFeePerGas,
+		nonce,
+	} satisfies WriteContractParameters as any);
+}

package/src/mantle/actions/initiateMNTWithdrawal.ts

@@ -0,0 +1,91 @@
+import type { Address } from "viem";
+import type { Client, FormattedTransactionRequest, Transport } from "viem";
+import type { Account } from "viem";
+import type { Chain, DeriveChain, GetChainParameter } from "viem";
+import type { Hash } from "viem";
+import type { UnionEvaluate, UnionOmit } from "viem";
+import {
+	writeContract,
+	type WriteContractErrorType,
+	type WriteContractParameters,
+} from "viem/actions";
+import { l2StandardBridge } from "../abis.js";
+import { contracts } from "../contracts.js";
+import type { ErrorType } from "../errors/utils.js";
+import type { GetAccountParameter } from "../types/account.js";
+import type { InitiateMNTWithdrawalRequest } from "../types/withdrawal.js";
+import { parseInitWithdrawequest } from "../utils/parseInitWithdrawRequest.js";
+
+export type InitiateMNTWithdrawalParameters<
+	chain extends Chain | undefined = Chain | undefined,
+	account extends Account | undefined = Account | undefined,
+	chainOverride extends Chain | undefined = Chain | undefined,
+	_derivedChain extends Chain | undefined = DeriveChain<chain, chainOverride>,
+> = UnionEvaluate<
+	UnionOmit<
+		FormattedTransactionRequest<_derivedChain>,
+		| "accessList"
+		| "data"
+		| "from"
+		| "gas"
+		| "gasPrice"
+		| "to"
+		| "type"
+		| "value"
+	>
+> &
+	GetAccountParameter<account, Account | Address> &
+	GetChainParameter<chain, chainOverride> & {
+		/**
+		 * Gas limit for transaction execution on the L2.
+		 */
+		gas?: bigint | undefined;
+		/** Withdrawal request. Supplied to the L2ToL1MessagePasser `initiateMNTWithdrawal` method. */
+		request: InitiateMNTWithdrawalRequest;
+	};
+export type InitiateMNTWithdrawalReturnType = Hash;
+export type InitiateMNTWithdrawalErrorType = WriteContractErrorType | ErrorType;
+
+/**
+ * @param client - Client to use
+ * @param parameters - {@link InitiateMNTWithdrawalParameters}
+ * @returns The L2 transaction hash. {@link InitiateMNTWithdrawalReturnType}
+ */
+export async function initiateMNTWithdrawal<
+	chain extends Chain | undefined,
+	account extends Account | undefined,
+	chainOverride extends Chain | undefined = undefined,
+>(
+	client: Client<Transport, chain, account>,
+	parameters: InitiateMNTWithdrawalParameters<chain, account, chainOverride>,
+) {
+	const {
+		account,
+		chain = client.chain,
+		gas,
+		maxFeePerGas,
+		maxPriorityFeePerGas,
+		nonce,
+		request: { amount, to },
+	} = parameters;
+
+	const { functionName, args } = parseInitWithdrawequest({
+		type: "mnt",
+		amount,
+		to,
+	});
+
+	return writeContract(client, {
+		account: account!,
+		abi: l2StandardBridge,
+		address: contracts.l2StandardBridge.address,
+		chain,
+		functionName,
+		args,
+		gas,
+		maxFeePerGas,
+		maxPriorityFeePerGas,
+		nonce,
+		value: amount,
+	} satisfies WriteContractParameters as any);
+}

package/src/mantle/actions/proveWithdrawal.ts

@@ -0,0 +1,107 @@
+import type { Address } from "viem";
+import type { Client, FormattedTransactionRequest, Transport } from "viem";
+import type { Account } from "viem";
+import type { Chain, DeriveChain, GetChainParameter } from "viem";
+import type { Hash, Hex } from "viem";
+import type { UnionEvaluate, UnionOmit } from "viem";
+import {
+	writeContract,
+	type WriteContractErrorType,
+	type WriteContractParameters,
+} from "viem/actions";
+import { portalAbi } from "../abis.js";
+import type { ErrorType } from "../errors/utils.js";
+import type { GetAccountParameter } from "../types/account.js";
+import type { GetContractAddressParameter } from "../types/contract.js";
+import type { Withdrawal } from "../types/withdrawal.js";
+import type { EstimateProveWithdrawalGasErrorType } from "./estimateProveWithdrawalGas.js";
+
+export type ProveWithdrawalParameters<
+	chain extends Chain | undefined = Chain | undefined,
+	account extends Account | undefined = Account | undefined,
+	chainOverride extends Chain | undefined = Chain | undefined,
+	_derivedChain extends Chain | undefined = DeriveChain<chain, chainOverride>,
+> = UnionEvaluate<
+	UnionOmit<
+		FormattedTransactionRequest<_derivedChain>,
+		| "accessList"
+		| "blobs"
+		| "data"
+		| "from"
+		| "gas"
+		| "maxFeePerBlobGas"
+		| "gasPrice"
+		| "to"
+		| "type"
+		| "value"
+	>
+> &
+	GetAccountParameter<account, Account | Address> &
+	GetChainParameter<chain, chainOverride> &
+	GetContractAddressParameter<_derivedChain, "portal"> & {
+		/**
+		 * Gas limit for transaction execution on the L1.
+		 */
+		gas?: bigint | undefined;
+		l2OutputIndex: bigint;
+		outputRootProof: {
+			version: Hex;
+			stateRoot: Hex;
+			messagePasserStorageRoot: Hex;
+			latestBlockhash: Hex;
+		};
+		withdrawalProof: readonly Hex[];
+		withdrawal: Withdrawal;
+	};
+export type ProveWithdrawalReturnType = Hash;
+export type ProveWithdrawalErrorType =
+	| EstimateProveWithdrawalGasErrorType
+	| WriteContractErrorType
+	| ErrorType;
+
+/**
+ * @param client - Client to use
+ * @param parameters - {@link ProveWithdrawalParameters}
+ * @returns The prove transaction hash. {@link ProveWithdrawalReturnType}
+ */
+export async function proveWithdrawal<
+	chain extends Chain | undefined,
+	account extends Account | undefined,
+	chainOverride extends Chain | undefined = undefined,
+>(
+	client: Client<Transport, chain, account>,
+	parameters: ProveWithdrawalParameters<chain, account, chainOverride>,
+): Promise<ProveWithdrawalReturnType> {
+	const {
+		account,
+		chain = client.chain,
+		gas,
+		l2OutputIndex,
+		maxFeePerGas,
+		maxPriorityFeePerGas,
+		nonce,
+		outputRootProof,
+		targetChain,
+		withdrawalProof,
+		withdrawal,
+	} = parameters;
+
+	const portalAddress = (() => {
+		if (parameters.portalAddress) return parameters.portalAddress;
+		if (chain) return targetChain!.contracts.portal[chain.id].address;
+		return Object.values(targetChain!.contracts.portal)[0].address;
+	})();
+
+	return writeContract(client, {
+		account: account!,
+		abi: portalAbi,
+		address: portalAddress,
+		chain,
+		functionName: "proveWithdrawalTransaction",
+		args: [withdrawal, l2OutputIndex, outputRootProof, withdrawalProof],
+		gas,
+		maxFeePerGas,
+		maxPriorityFeePerGas,
+		nonce,
+	} satisfies WriteContractParameters as any);
+}

package/src/mantle/actions/waitForNextL2Output.ts

@@ -0,0 +1,87 @@
+import type { Client, Transport } from "viem";
+import { ContractFunctionRevertedError } from "viem";
+import type { Account } from "viem";
+import type { Chain, DeriveChain, GetChainParameter } from "viem";
+import type { ErrorType } from "../errors/utils.js";
+import type { GetContractAddressParameter } from "../types/contract.js";
+import { poll } from "../utils/poll.js";
+import {
+	getL2Output,
+	type GetL2OutputErrorType,
+	type GetL2OutputParameters,
+	type GetL2OutputReturnType,
+} from "./getL2Output.js";
+import {
+	getTimeToNextL2Output,
+	type GetTimeToNextL2OutputErrorType,
+	type GetTimeToNextL2OutputParameters,
+} from "./getTimeToNextL2Output.js";
+
+export type WaitForNextL2OutputParameters<
+	chain extends Chain | undefined = Chain | undefined,
+	chainOverride extends Chain | undefined = Chain | undefined,
+	_derivedChain extends Chain | undefined = DeriveChain<chain, chainOverride>,
+> = GetChainParameter<chain, chainOverride> &
+	GetContractAddressParameter<_derivedChain, "l2OutputOracle"> & {
+		/**
+		 * The buffer to account for discrepancies between non-deterministic time intervals.
+		 * @default 1.1
+		 */
+		intervalBuffer?:
+			| GetTimeToNextL2OutputParameters["intervalBuffer"]
+			| undefined;
+		l2BlockNumber: bigint;
+		/**
+		 * Polling frequency (in ms). Defaults to Client's pollingInterval config.
+		 * @default client.pollingInterval
+		 */
+		pollingInterval?: number | undefined;
+	};
+export type WaitForNextL2OutputReturnType = GetL2OutputReturnType;
+export type WaitForNextL2OutputErrorType =
+	| GetL2OutputErrorType
+	| GetTimeToNextL2OutputErrorType
+	| ErrorType;
+
+/**
+ * @param client - Client to use
+ * @param parameters - {@link WaitForNextL2OutputParameters}
+ * @returns The L2 transaction hash. {@link WaitForNextL2OutputReturnType}
+ */
+export async function waitForNextL2Output<
+	chain extends Chain | undefined,
+	account extends Account | undefined,
+	chainOverride extends Chain | undefined = undefined,
+>(
+	client: Client<Transport, chain, account>,
+	parameters: WaitForNextL2OutputParameters<chain, chainOverride>,
+): Promise<WaitForNextL2OutputReturnType> {
+	const { pollingInterval = client.pollingInterval } = parameters;
+
+	const { seconds } = await getTimeToNextL2Output(client, parameters);
+
+	return new Promise((resolve, reject) => {
+		poll(
+			async ({ unpoll }) => {
+				try {
+					const output = await getL2Output(
+						client,
+						parameters as GetL2OutputParameters,
+					);
+					unpoll();
+					resolve(output);
+				} catch (e) {
+					const error = e as GetL2OutputErrorType;
+					if (!(error.cause instanceof ContractFunctionRevertedError)) {
+						unpoll();
+						reject(e);
+					}
+				}
+			},
+			{
+				interval: pollingInterval,
+				initialWaitTime: async () => seconds * 1000,
+			},
+		);
+	});
+}