@mantleio/viem 0.0.1-alpha.0

package/src/mantle/actions/finalizeWithdrawal.ts

@@ -0,0 +1,95 @@
+import type { Address } from "viem";
+import type { Client, 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 type { FormattedTransactionRequest } from "viem/utils";
+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 { EstimateFinalizeWithdrawalGasErrorType } from "./estimateFinalizeWithdrawalGas.js";
+
+export type FinalizeWithdrawalParameters<
+	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> &
+	GetContractAddressParameter<_derivedChain, "portal"> & {
+		/**
+		 * Gas limit for transaction execution on the L1.
+		 */
+		gas?: bigint | undefined;
+		withdrawal: Withdrawal;
+	};
+export type FinalizeWithdrawalReturnType = Hash;
+export type FinalizeWithdrawalErrorType =
+	| EstimateFinalizeWithdrawalGasErrorType
+	| WriteContractErrorType
+	| ErrorType;
+
+/**
+ * @param client - Client to use
+ * @param parameters - {@link FinalizeWithdrawalParameters}
+ * @returns The finalize transaction hash. {@link FinalizeWithdrawalReturnType}
+ */
+export async function finalizeWithdrawal<
+	chain extends Chain | undefined,
+	account extends Account | undefined,
+	chainOverride extends Chain | undefined = undefined,
+>(
+	client: Client<Transport, chain, account>,
+	parameters: FinalizeWithdrawalParameters<chain, account, chainOverride>,
+): Promise<FinalizeWithdrawalReturnType> {
+	const {
+		account,
+		chain = client.chain,
+		gas,
+		maxFeePerGas,
+		maxPriorityFeePerGas,
+		nonce,
+		targetChain,
+		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: "finalizeWithdrawalTransaction",
+		args: [withdrawal],
+		gas,
+		maxFeePerGas,
+		maxPriorityFeePerGas,
+		nonce,
+	} satisfies WriteContractParameters as any);
+}

package/src/mantle/actions/getL2Output.ts

@@ -0,0 +1,75 @@
+import type { Account, Client, Transport } from "viem";
+import type { Chain, DeriveChain, GetChainParameter } from "viem";
+import type { Hex } from "viem";
+import type { OneOf } from "viem";
+import { readContract, type ReadContractErrorType } from "viem/actions";
+import { l2OutputOracleAbi } from "../abis.js";
+import type { ErrorType } from "../errors/utils.js";
+import type { TargetChain } from "../types/chain.js";
+import type { GetContractAddressParameter } from "../types/contract.js";
+
+export type GetL2OutputParameters<
+	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">
+		| GetContractAddressParameter<_derivedChain, "portal">
+	> & {
+		l2BlockNumber: bigint;
+	};
+export type GetL2OutputReturnType = {
+	outputIndex: bigint;
+	outputRoot: Hex;
+	timestamp: bigint;
+	l2BlockNumber: bigint;
+};
+export type GetL2OutputErrorType = ReadContractErrorType | ErrorType;
+
+/**
+ * @param client - Client to use
+ * @param parameters - {@link GetL2OutputParameters}
+ * @returns The L2 output. {@link GetL2OutputReturnType}
+ */
+export async function getL2Output<
+	chain extends Chain | undefined,
+	account extends Account | undefined,
+	chainOverride extends Chain | undefined = undefined,
+>(
+	client: Client<Transport, chain, account>,
+	parameters: GetL2OutputParameters<chain, chainOverride>,
+): Promise<GetL2OutputReturnType> {
+	const { chain = client.chain, l2BlockNumber, targetChain } = parameters;
+
+	const l2OutputOracleAddress = (() => {
+		if (parameters.l2OutputOracleAddress) {
+			return parameters.l2OutputOracleAddress;
+		}
+		if (chain) {
+			return (targetChain as unknown as TargetChain)!.contracts.l2OutputOracle[
+				chain.id
+			].address;
+		}
+		return (
+			Object.values(
+				(targetChain as unknown as TargetChain)!.contracts.l2OutputOracle,
+			) as any
+		)[0].address;
+	})();
+
+	const outputIndex = await readContract(client, {
+		address: l2OutputOracleAddress,
+		abi: l2OutputOracleAbi,
+		functionName: "getL2OutputIndexAfter",
+		args: [l2BlockNumber],
+	});
+	const output = await readContract(client, {
+		address: l2OutputOracleAddress,
+		abi: l2OutputOracleAbi,
+		functionName: "getL2Output",
+		args: [outputIndex],
+	});
+
+	return { outputIndex, ...output };
+}

package/src/mantle/actions/getPortalVersion.ts

@@ -0,0 +1,57 @@
+import type { Client, Transport } from "viem";
+import type { Chain, DeriveChain, GetChainParameter } from "viem";
+import { readContract, type ReadContractErrorType } from "viem/actions";
+import { portal2Abi } from "../abis.js";
+import type { ErrorType } from "../errors/utils.js";
+import type { GetContractAddressParameter } from "../types/contract.js";
+import { withCache } from "../utils/promise/withCache.js";
+
+export type GetPortalVersionParameters<
+	chain extends Chain | undefined = Chain | undefined,
+	chainOverride extends Chain | undefined = Chain | undefined,
+	_derivedChain extends Chain | undefined = DeriveChain<chain, chainOverride>,
+> = GetChainParameter<chain, chainOverride> &
+	GetContractAddressParameter<_derivedChain, "portal">;
+
+export type GetPortalVersionReturnType = {
+	major: number;
+	minor: number;
+	patch: number;
+};
+
+export type GetPortalVersionErrorType = ReadContractErrorType | ErrorType;
+
+/**
+ * @param client - Client to use
+ * @param parameters - {@link GetPortalVersionParameters}
+ * @returns The version object.
+ */
+export async function getPortalVersion<
+	chain extends Chain | undefined,
+	chainOverride extends Chain | undefined = undefined,
+>(
+	client: Client<Transport, chain>,
+	parameters: GetPortalVersionParameters<chain, chainOverride>,
+) {
+	const { chain = client.chain, targetChain } = 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;
+	})();
+
+	const version = await withCache(
+		() =>
+			readContract(client, {
+				abi: portal2Abi,
+				address: portalAddress,
+				functionName: "version",
+			}),
+		{ cacheKey: ["portalVersion", portalAddress].join("."), cacheTime: 300 },
+	);
+
+	const [major, minor, patch] = version.split(".").map(Number);
+
+	return { major, minor, patch };
+}

package/src/mantle/actions/getTimeToFinalize.ts

@@ -0,0 +1,85 @@
+import type { Client, Transport } from "viem";
+import type { Account } from "viem";
+import type { Chain, DeriveChain, GetChainParameter } from "viem";
+import type { Hash } from "viem";
+import { multicall, type MulticallErrorType } from "viem/actions";
+import { l2OutputOracleAbi, portalAbi } from "../abis.js";
+import type { ErrorType } from "../errors/utils.js";
+import type { GetContractAddressParameter } from "../types/contract.js";
+
+export type GetTimeToFinalizeParameters<
+	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" | "portal"> & {
+		withdrawalHash: Hash;
+	};
+export type GetTimeToFinalizeReturnType = {
+	/** The finalization period (in seconds). */
+	period: number;
+	/** Seconds until the withdrawal can be finalized. */
+	seconds: number;
+	/** Timestamp of when the withdrawal can be finalized. */
+	timestamp: number;
+};
+export type GetTimeToFinalizeErrorType = MulticallErrorType | ErrorType;
+
+const buffer = 10;
+
+/**
+ * @param client - Client to use
+ * @param parameters - {@link GetTimeToFinalizeParameters}
+ * @returns Time until finalize. {@link GetTimeToFinalizeReturnType}
+ */
+export async function getTimeToFinalize<
+	chain extends Chain | undefined,
+	account extends Account | undefined,
+	chainOverride extends Chain | undefined = undefined,
+>(
+	client: Client<Transport, chain, account>,
+	parameters: GetTimeToFinalizeParameters<chain, chainOverride>,
+): Promise<GetTimeToFinalizeReturnType> {
+	const { chain = client.chain, withdrawalHash, targetChain } = 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;
+	})();
+
+	const l2OutputOracleAddress = (() => {
+		if (parameters.l2OutputOracleAddress) {
+			return parameters.l2OutputOracleAddress;
+		}
+		if (chain) return targetChain!.contracts.l2OutputOracle[chain.id].address;
+		return Object.values(targetChain!.contracts.l2OutputOracle)[0].address;
+	})();
+	const [[_outputRoot, proveTimestamp, _l2OutputIndex], period] =
+		await multicall(client, {
+			allowFailure: false,
+			contracts: [
+				{
+					abi: portalAbi,
+					address: portalAddress,
+					functionName: "provenWithdrawals",
+					args: [withdrawalHash],
+				},
+				{
+					abi: l2OutputOracleAbi,
+					address: l2OutputOracleAddress,
+					functionName: "FINALIZATION_PERIOD_SECONDS",
+				},
+			],
+		});
+
+	const secondsSinceProven = Date.now() / 1000 - Number(proveTimestamp);
+	const secondsToFinalize = Number(period) - secondsSinceProven;
+
+	const seconds = Math.floor(
+		secondsToFinalize < 0 ? 0 : secondsToFinalize + buffer,
+	);
+	const timestamp = Date.now() + seconds * 1000;
+
+	return { period: Number(period), seconds, timestamp };
+}

package/src/mantle/actions/getTimeToNextL2Output.ts

@@ -0,0 +1,132 @@
+import type { Account, Client, Transport } from "viem";
+import type { Chain, DeriveChain, GetChainParameter } from "viem";
+import {
+	multicall,
+	type MulticallErrorType,
+	readContract,
+	type ReadContractErrorType,
+} from "viem/actions";
+import { l2OutputOracleAbi } from "../abis.js";
+import type { ErrorType } from "../errors/utils.js";
+import type { GetContractAddressParameter } from "../types/contract.js";
+
+export type GetTimeToNextL2OutputParameters<
+	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?: number | undefined;
+		l2BlockNumber: bigint;
+	};
+export type GetTimeToNextL2OutputReturnType = {
+	/** The interval (in seconds) between L2 outputs. */
+	interval: number;
+	/**
+	 * Seconds until the next L2 output.
+	 * `0` if the next L2 output has already been submitted.
+	 */
+	seconds: number;
+	/**
+	 * Estimated timestamp of the next L2 output.
+	 * `undefined` if the next L2 output has already been submitted.
+	 */
+	timestamp?: number | undefined;
+};
+export type GetTimeToNextL2OutputErrorType =
+	| MulticallErrorType
+	| ReadContractErrorType
+	| ErrorType;
+
+/**
+ * @param client - Client to use
+ * @param parameters - {@link GetTimeToNextL2OutputParameters}
+ * @returns The L2 transaction hash. {@link GetTimeToNextL2OutputReturnType}
+ */
+export async function getTimeToNextL2Output<
+	chain extends Chain | undefined,
+	account extends Account | undefined,
+	chainOverride extends Chain | undefined = undefined,
+>(
+	client: Client<Transport, chain, account>,
+	parameters: GetTimeToNextL2OutputParameters<chain, chainOverride>,
+): Promise<GetTimeToNextL2OutputReturnType> {
+	const {
+		intervalBuffer = 1.1,
+		chain = client.chain,
+		l2BlockNumber,
+		targetChain,
+	} = parameters;
+
+	const l2OutputOracleAddress = (() => {
+		if (parameters.l2OutputOracleAddress) {
+			return parameters.l2OutputOracleAddress;
+		}
+		if (chain) return targetChain!.contracts.l2OutputOracle[chain.id].address;
+		return Object.values(targetChain!.contracts.l2OutputOracle)[0].address;
+	})();
+
+	const [latestOutputIndex, blockTime, blockInterval] = await multicall(
+		client,
+		{
+			allowFailure: false,
+			contracts: [
+				{
+					abi: l2OutputOracleAbi,
+					address: l2OutputOracleAddress,
+					functionName: "latestOutputIndex",
+				},
+				{
+					abi: l2OutputOracleAbi,
+					address: l2OutputOracleAddress,
+					functionName: "L2_BLOCK_TIME",
+				},
+				{
+					abi: l2OutputOracleAbi,
+					address: l2OutputOracleAddress,
+					functionName: "SUBMISSION_INTERVAL",
+				},
+			],
+		},
+	);
+	const latestOutput = await readContract(client, {
+		abi: l2OutputOracleAbi,
+		address: l2OutputOracleAddress,
+		functionName: "getL2Output",
+		args: [latestOutputIndex],
+	});
+	const latestOutputTimestamp = Number(latestOutput.timestamp) * 1000;
+
+	const interval = Number(blockInterval * blockTime);
+	const intervalWithBuffer = Math.ceil(interval * intervalBuffer);
+
+	const now = Date.now();
+
+	const seconds = (() => {
+		// If the current timestamp is lesser than the latest L2 output timestamp,
+		// then we assume that the L2 output has already been submitted.
+		if (now < latestOutputTimestamp) return 0;
+
+		// If the latest L2 output block is newer than the provided L2 block number,
+		// then we assume that the L2 output has already been submitted.
+		if (latestOutput.l2BlockNumber > l2BlockNumber) return 0;
+
+		const elapsedBlocks = Number(l2BlockNumber - latestOutput.l2BlockNumber);
+
+		const elapsed = Math.ceil((now - latestOutputTimestamp) / 1000);
+		const secondsToNextOutput =
+			intervalWithBuffer - (elapsed % intervalWithBuffer);
+		return elapsedBlocks < blockInterval
+			? secondsToNextOutput
+			: Math.floor(elapsedBlocks / Number(blockInterval)) * intervalWithBuffer +
+					secondsToNextOutput;
+	})();
+
+	const timestamp = seconds > 0 ? now + seconds * 1000 : undefined;
+
+	return { interval, seconds, timestamp };
+}

package/src/mantle/actions/getTimeToProve.ts

@@ -0,0 +1,58 @@
+import type { Account, Client, Transport } from "viem";
+import type { Chain, DeriveChain, GetChainParameter } from "viem";
+import type { TransactionReceipt } from "viem";
+import type { OneOf } from "viem";
+import type { ErrorType } from "../errors/utils.js";
+import type { GetContractAddressParameter } from "../types/contract.js";
+import {
+	getTimeToNextL2Output,
+	type GetTimeToNextL2OutputErrorType,
+	type GetTimeToNextL2OutputParameters,
+	type GetTimeToNextL2OutputReturnType,
+} from "./getTimeToNextL2Output.js";
+
+export type GetTimeToProveParameters<
+	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">
+		| GetContractAddressParameter<_derivedChain, "portal">
+	> & {
+		/**
+		 * The buffer to account for discrepancies between non-deterministic time intervals.
+		 * @default 1.1
+		 */
+		intervalBuffer?:
+			| GetTimeToNextL2OutputParameters["intervalBuffer"]
+			| undefined;
+		receipt: TransactionReceipt;
+	};
+
+export type GetTimeToProveReturnType = GetTimeToNextL2OutputReturnType;
+
+export type GetTimeToProveErrorType =
+	| GetTimeToNextL2OutputErrorType
+	| ErrorType;
+
+/**
+ * @param client - Client to use
+ * @param parameters - {@link GetTimeToNextL2OutputParameters}
+ * @returns Time until prove step is ready. {@link GetTimeToNextL2OutputReturnType}
+ */
+export async function getTimeToProve<
+	chain extends Chain | undefined,
+	account extends Account | undefined,
+	chainOverride extends Chain | undefined = undefined,
+>(
+	client: Client<Transport, chain, account>,
+	parameters: GetTimeToProveParameters<chain, chainOverride>,
+): Promise<GetTimeToProveReturnType> {
+	const { receipt } = parameters;
+
+	return getTimeToNextL2Output(client, {
+		...parameters,
+		l2BlockNumber: receipt.blockNumber,
+	} as GetTimeToNextL2OutputParameters);
+}