@mantleio/viem 0.0.1-alpha.0

package/src/mantle/actions/waitToFinalize.ts

@@ -0,0 +1,33 @@
+import type { Client, Transport } from "viem";
+import type { Chain } from "viem";
+import type { Account } from "viem";
+import type { ErrorType } from "../errors/utils.js";
+import { wait } from "../utils/wait.js";
+import {
+	getTimeToFinalize,
+	type GetTimeToFinalizeErrorType,
+	type GetTimeToFinalizeParameters,
+} from "./getTimeToFinalize.js";
+
+export type WaitToFinalizeParameters<
+	chain extends Chain | undefined = Chain | undefined,
+	chainOverride extends Chain | undefined = Chain | undefined,
+> = GetTimeToFinalizeParameters<chain, chainOverride>;
+export type WaitToFinalizeReturnType = void;
+export type WaitToFinalizeErrorType = GetTimeToFinalizeErrorType | ErrorType;
+
+/**
+ * @param client - Client to use
+ * @param parameters - {@link WaitToFinalizeParameters}
+ */
+export async function waitToFinalize<
+	chain extends Chain | undefined,
+	account extends Account | undefined,
+	chainOverride extends Chain | undefined = undefined,
+>(
+	client: Client<Transport, chain, account>,
+	parameters: WaitToFinalizeParameters<chain, chainOverride>,
+): Promise<WaitToFinalizeReturnType> {
+	const { seconds } = await getTimeToFinalize(client, parameters);
+	await wait(seconds * 1000);
+}

package/src/mantle/actions/waitToProve.ts

@@ -0,0 +1,83 @@
+import type {
+	Account,
+	Chain,
+	Client,
+	DeriveChain,
+	GetChainParameter,
+	TransactionReceipt,
+	Transport,
+} from "viem";
+import type { OneOf } from "viem";
+import type { ErrorType } from "../errors/utils.js";
+import { ReceiptContainsNoWithdrawalsError } from "../errors/withdrawal.js";
+import type { GetContractAddressParameter } from "../types/contract.js";
+import type { Withdrawal } from "../types/withdrawal.js";
+import {
+	getWithdrawals,
+	type GetWithdrawalsErrorType,
+} from "../utils/getWithdrawals.js";
+import {
+	waitForNextL2Output,
+	type WaitForNextL2OutputErrorType,
+	type WaitForNextL2OutputParameters,
+	type WaitForNextL2OutputReturnType,
+} from "./waitForNextL2Output.js";
+
+export type WaitToProveParameters<
+	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">
+	> & {
+		receipt: TransactionReceipt;
+		/**
+		 * Polling frequency (in ms). Defaults to Client's pollingInterval config.
+		 * @default client.pollingInterval
+		 */
+		pollingInterval?: number | undefined;
+	};
+export type WaitToProveReturnType = {
+	output: WaitForNextL2OutputReturnType;
+	withdrawal: Withdrawal;
+};
+
+export type WaitToProveErrorType =
+	| GetWithdrawalsErrorType
+	| WaitForNextL2OutputErrorType
+	| ErrorType;
+
+/**
+ * @param client - Client to use
+ * @param parameters - {@link WaitToProveParameters}
+ * @returns The L2 output and withdrawal message. {@link WaitToProveReturnType}
+ */
+export async function waitToProve<
+	chain extends Chain | undefined,
+	account extends Account | undefined,
+	chainOverride extends Chain | undefined = undefined,
+>(
+	client: Client<Transport, chain, account>,
+	parameters: WaitToProveParameters<chain, chainOverride>,
+): Promise<WaitToProveReturnType> {
+	const { receipt } = parameters;
+
+	const [withdrawal] = getWithdrawals(receipt);
+
+	if (!withdrawal) {
+		throw new ReceiptContainsNoWithdrawalsError({
+			hash: receipt.transactionHash,
+		});
+	}
+
+	const output = await waitForNextL2Output(client, {
+		...parameters,
+		l2BlockNumber: receipt.blockNumber,
+	} as WaitForNextL2OutputParameters);
+	return {
+		output,
+		withdrawal,
+	};
+}

package/src/mantle/chainConfig.ts

@@ -0,0 +1,9 @@
+import { contracts } from "./contracts.js";
+import { formatters } from "./formatters.js";
+import { serializers } from "./serializers.js";
+
+export const chainConfig = {
+	contracts,
+	formatters,
+	serializers,
+} as const;

package/src/mantle/chains/index.ts

@@ -0,0 +1,2 @@
+export { mantle } from "./mantle.js";
+export { mantleSepoliaTestnet } from "./mantleSepoliaTestnet.js";

package/src/mantle/chains/mantle.ts

@@ -0,0 +1,51 @@
+import { defineChain } from "viem";
+import { chainConfig } from "viem/op-stack";
+
+const sourceId = 1; // mainnet
+
+export const mantle = /*#__PURE__*/ defineChain({
+	...chainConfig,
+	id: 5000,
+	name: "Mantle",
+	nativeCurrency: {
+		decimals: 18,
+		name: "MNT",
+		symbol: "MNT",
+	},
+	rpcUrls: {
+		default: { http: ["https://rpc.mantle.xyz"] },
+	},
+	blockExplorers: {
+		default: {
+			name: "Mantle Explorer",
+			url: "https://mantlescan.xyz/",
+			apiUrl: "https://api.mantlescan.xyz/api",
+		},
+	},
+	contracts: {
+		...chainConfig.contracts,
+		l2Erc721Bridge: undefined,
+		l2OutputOracle: {
+			[sourceId]: {
+				address: "0x31d543e7BE1dA6eFDc2206Ef7822879045B9f481",
+			},
+		},
+		portal: {
+			[sourceId]: {
+				address: "0xc54cb22944F2bE476E02dECfCD7e3E7d3e15A8Fb",
+				blockCreated: 19434938,
+			},
+		},
+		l1StandardBridge: {
+			[sourceId]: {
+				address: "0x95fC37A27a2f68e3A647CDc081F0A89bb47c3012",
+				blockCreated: 17577718,
+			},
+		},
+		multicall3: {
+			address: "0xcA11bde05977b3631167028862bE2a173976CA11",
+			blockCreated: 304717,
+		},
+	},
+	sourceId,
+});

package/src/mantle/chains/mantleSepoliaTestnet.ts

@@ -0,0 +1,52 @@
+import { defineChain } from "viem";
+import { chainConfig } from "viem/op-stack";
+
+const sourceId = 11_155_111; // sepolia
+
+export const mantleSepoliaTestnet = /*#__PURE__*/ defineChain({
+	...chainConfig,
+	id: 5003,
+	name: "Mantle Sepolia Testnet",
+	nativeCurrency: {
+		decimals: 18,
+		name: "MNT",
+		symbol: "MNT",
+	},
+	rpcUrls: {
+		default: { http: ["https://rpc.sepolia.mantle.xyz"] },
+	},
+	blockExplorers: {
+		default: {
+			name: "Mantle Testnet Explorer",
+			url: "https://explorer.sepolia.mantle.xyz/",
+			apiUrl: "https://explorer.sepolia.mantle.xyz/api",
+		},
+	},
+	contracts: {
+		...chainConfig.contracts,
+		l2Erc721Bridge: undefined,
+		l2OutputOracle: {
+			[sourceId]: {
+				address: "0x4121dc8e48Bc6196795eb4867772A5e259fecE07",
+			},
+		},
+		portal: {
+			[sourceId]: {
+				address: "0xB3db4bd5bc225930eD674494F9A4F6a11B8EFBc8",
+				blockCreated: 4858030,
+			},
+		},
+		l1StandardBridge: {
+			[sourceId]: {
+				address: "0x21F308067241B2028503c07bd7cB3751FFab0Fb2",
+				blockCreated: 4852137,
+			},
+		},
+		multicall3: {
+			address: "0xcA11bde05977b3631167028862bE2a173976CA11",
+			blockCreated: 4584012,
+		},
+	},
+	testnet: true,
+	sourceId,
+});

package/src/mantle/contracts.ts

@@ -0,0 +1,14 @@
+import type { Chain } from "viem";
+
+export const contracts = {
+	gasPriceOracle: { address: "0x420000000000000000000000000000000000000F" },
+	l1Block: { address: "0x4200000000000000000000000000000000000015" },
+	l2CrossDomainMessenger: {
+		address: "0x4200000000000000000000000000000000000007",
+	},
+	l2Erc721Bridge: { address: "0x4200000000000000000000000000000000000014" },
+	l2StandardBridge: { address: "0x4200000000000000000000000000000000000010" },
+	l2ToL1MessagePasser: {
+		address: "0x4200000000000000000000000000000000000016",
+	},
+} as const satisfies Chain["contracts"];

package/src/mantle/decorators/publicL1.ts

@@ -0,0 +1,182 @@
+import type { Client, Transport } from "viem";
+import type { Chain } from "viem";
+import type { Account } from "viem";
+
+import {
+	estimateDepositETHGas,
+	type EstimateDepositETHGasParameters,
+	type EstimateDepositETHGasReturnType,
+} from "../actions/estimateDepositETHGas.js";
+import {
+	estimateDepositMNTGas,
+	type EstimateDepositMNTGasParameters,
+	type EstimateDepositMNTGasReturnType,
+} from "../actions/estimateDepositMNTGas.js";
+import {
+	estimateFinalizeWithdrawalGas,
+	type EstimateFinalizeWithdrawalGasParameters,
+	type EstimateFinalizeWithdrawalGasReturnType,
+} from "../actions/estimateFinalizeWithdrawalGas.js";
+import {
+	estimateProveWithdrawalGas,
+	type EstimateProveWithdrawalGasParameters,
+	type EstimateProveWithdrawalGasReturnType,
+} from "../actions/estimateProveWithdrawalGas.js";
+import {
+	getL2Output,
+	type GetL2OutputParameters,
+	type GetL2OutputReturnType,
+} from "../actions/getL2Output.js";
+import {
+	getPortalVersion,
+	type GetPortalVersionParameters,
+	type GetPortalVersionReturnType,
+} from "../actions/getPortalVersion.js";
+import {
+	getTimeToFinalize,
+	type GetTimeToFinalizeParameters,
+	type GetTimeToFinalizeReturnType,
+} from "../actions/getTimeToFinalize.js";
+import {
+	getTimeToNextL2Output,
+	type GetTimeToNextL2OutputParameters,
+	type GetTimeToNextL2OutputReturnType,
+} from "../actions/getTimeToNextL2Output.js";
+import {
+	getTimeToProve,
+	type GetTimeToProveParameters,
+	type GetTimeToProveReturnType,
+} from "../actions/getTimeToProve.js";
+import {
+	getWithdrawalStatus,
+	type GetWithdrawalStatusParameters,
+	type GetWithdrawalStatusReturnType,
+} from "../actions/getWithdrawalStatus.js";
+import {
+	waitForNextL2Output,
+	type WaitForNextL2OutputParameters,
+	type WaitForNextL2OutputReturnType,
+} from "../actions/waitForNextL2Output.js";
+import {
+	waitToFinalize,
+	type WaitToFinalizeParameters,
+	type WaitToFinalizeReturnType,
+} from "../actions/waitToFinalize.js";
+import {
+	waitToProve,
+	type WaitToProveParameters,
+	type WaitToProveReturnType,
+} from "../actions/waitToProve.js";
+
+import {
+	estimateDepositERC20Gas,
+	type EstimateDepositERC20GasParameters,
+	type EstimateDepositERC20GasReturnType,
+} from "../actions/estimateDepositERC20Gas.js";
+
+export type PublicActionsL1<
+	chain extends Chain | undefined = Chain | undefined,
+	account extends Account | undefined = Account | undefined,
+> = {
+	estimateProveWithdrawalGas: <
+		chainOverride extends Chain | undefined = undefined,
+	>(
+		parameters: EstimateProveWithdrawalGasParameters<
+			chain,
+			account,
+			chainOverride
+		>,
+	) => Promise<EstimateProveWithdrawalGasReturnType>;
+
+	estimateFinalizeWithdrawalGas: <
+		chainOverride extends Chain | undefined = undefined,
+	>(
+		parameters: EstimateFinalizeWithdrawalGasParameters<
+			chain,
+			account,
+			chainOverride
+		>,
+	) => Promise<EstimateFinalizeWithdrawalGasReturnType>;
+
+	getL2Output: <chainOverride extends Chain | undefined = undefined>(
+		parameters: GetL2OutputParameters<chain, chainOverride>,
+	) => Promise<GetL2OutputReturnType>;
+
+	getPortalVersion: <chainOverride extends Chain | undefined = undefined>(
+		parameters: GetPortalVersionParameters<chain, chainOverride>,
+	) => Promise<GetPortalVersionReturnType>;
+
+	getTimeToFinalize: <chainOverride extends Chain | undefined = undefined>(
+		parameters: GetTimeToFinalizeParameters<chain, chainOverride>,
+	) => Promise<GetTimeToFinalizeReturnType>;
+
+	getTimeToNextL2Output: <chainOverride extends Chain | undefined = undefined>(
+		parameters: GetTimeToNextL2OutputParameters<chain, chainOverride>,
+	) => Promise<GetTimeToNextL2OutputReturnType>;
+
+	getTimeToProve: <chainOverride extends Chain | undefined = undefined>(
+		parameters: GetTimeToProveParameters<chain, chainOverride>,
+	) => Promise<GetTimeToProveReturnType>;
+
+	getWithdrawalStatus: <chainOverride extends Chain | undefined = undefined>(
+		parameters: GetWithdrawalStatusParameters<chain, chainOverride>,
+	) => Promise<GetWithdrawalStatusReturnType>;
+
+	waitForNextL2Output: <chainOverride extends Chain | undefined = undefined>(
+		parameters: WaitForNextL2OutputParameters<chain, chainOverride>,
+	) => Promise<WaitForNextL2OutputReturnType>;
+
+	waitToFinalize: <chainOverride extends Chain | undefined = undefined>(
+		parameters: WaitToFinalizeParameters<chain, chainOverride>,
+	) => Promise<WaitToFinalizeReturnType>;
+
+	waitToProve: <chainOverride extends Chain | undefined = undefined>(
+		parameters: WaitToProveParameters<chain, chainOverride>,
+	) => Promise<WaitToProveReturnType>;
+	estimateDepositMNTGas: <chainOverride extends Chain | undefined = undefined>(
+		parameters: EstimateDepositMNTGasParameters<chain, account, chainOverride>,
+	) => Promise<EstimateDepositMNTGasReturnType>;
+
+	estimateDepositETHGas: <chainOverride extends Chain | undefined = undefined>(
+		parameters: EstimateDepositETHGasParameters<chain, account, chainOverride>,
+	) => Promise<EstimateDepositETHGasReturnType>;
+
+	estimateDepositERC20Gas: <
+		chainOverride extends Chain | undefined = undefined,
+	>(
+		parameters: EstimateDepositERC20GasParameters<
+			chain,
+			account,
+			chainOverride
+		>,
+	) => Promise<EstimateDepositERC20GasReturnType>;
+};
+
+export function publicActionsL1() {
+	return <
+		transport extends Transport,
+		chain extends Chain | undefined = Chain | undefined,
+		account extends Account | undefined = Account | undefined,
+	>(
+		client: Client<transport, chain, account>,
+	): PublicActionsL1<chain, account> => {
+		return {
+			estimateFinalizeWithdrawalGas: (args) =>
+				estimateFinalizeWithdrawalGas(client, args),
+			estimateProveWithdrawalGas: (args) =>
+				estimateProveWithdrawalGas(client, args),
+			getL2Output: (args) => getL2Output(client, args),
+			getPortalVersion: (args) => getPortalVersion(client, args),
+			getTimeToFinalize: (args) => getTimeToFinalize(client, args),
+			getTimeToNextL2Output: (args) => getTimeToNextL2Output(client, args),
+			getTimeToProve: (args) => getTimeToProve(client, args),
+			getWithdrawalStatus: (args) => getWithdrawalStatus(client, args),
+			waitForNextL2Output: (args) => waitForNextL2Output(client, args),
+			waitToFinalize: (args) => waitToFinalize(client, args),
+			waitToProve: (args) => waitToProve(client, args),
+			estimateDepositMNTGas: (args) => estimateDepositMNTGas(client, args),
+			estimateDepositETHGas: (args) => estimateDepositETHGas(client, args),
+			estimateDepositERC20Gas: (args) => estimateDepositERC20Gas(client, args),
+		};
+	};
+}

package/src/mantle/decorators/publicL2.ts

@@ -0,0 +1,96 @@
+import type { Address } from "viem";
+import type { Client, Transport } from "viem";
+import type { Chain } from "viem";
+import type { Account } from "viem";
+import {
+	buildProveWithdrawal,
+	type BuildProveWithdrawalParameters,
+	type BuildProveWithdrawalReturnType,
+} from "../actions/buildProveWithdrawal.js";
+import {
+	estimateInitiateERC20Withdrawal,
+	type EstimateInitiateERC20WithdrawalGasReturnType,
+	type EstimateInitiateWithdrawalERC20GasParameters,
+} from "../actions/estimateInitiateERC20WithdrawalGas.js";
+import {
+	estimateInitiateETHWithdrawalGas,
+	type EstimateInitiateETHWithdrawalGasParameters,
+	type EstimateInitiateETHWithdrawalGasReturnType,
+} from "../actions/estimateInitiateETHWithdrawalGas.js";
+import {
+	estimateInitiateMNTWithdrawalGas,
+	type EstimateInitiateMNTWithdrawalGasParameters,
+	type EstimateInitiateMNTWithdrawalGasReturnType,
+} from "../actions/estimateInitiateMNTWithdrawalGas.js";
+
+export type PublicActionsL2<
+	chain extends Chain | undefined = Chain | undefined,
+	account extends Account | undefined = Account | undefined,
+> = {
+	buildProveWithdrawal: <
+		chainOverride extends Chain | undefined = undefined,
+		accountOverride extends Account | Address | undefined = undefined,
+	>(
+		parameters: BuildProveWithdrawalParameters<
+			chain,
+			account,
+			chainOverride,
+			accountOverride
+		>,
+	) => Promise<
+		BuildProveWithdrawalReturnType<
+			chain,
+			account,
+			chainOverride,
+			accountOverride
+		>
+	>;
+
+	estimateInitiateMNTWithdrawalGas: <
+		chainOverride extends Chain | undefined = undefined,
+	>(
+		parameters: EstimateInitiateMNTWithdrawalGasParameters<
+			chain,
+			account,
+			chainOverride
+		>,
+	) => Promise<EstimateInitiateMNTWithdrawalGasReturnType>;
+	estimateInitiateETHWithdrawalGas: <
+		chainOverride extends Chain | undefined = undefined,
+	>(
+		parameters: EstimateInitiateETHWithdrawalGasParameters<
+			chain,
+			account,
+			chainOverride
+		>,
+	) => Promise<EstimateInitiateETHWithdrawalGasReturnType>;
+	estimateInitiateERC20Withdrawal: <
+		chainOverride extends Chain | undefined = undefined,
+	>(
+		parameters: EstimateInitiateWithdrawalERC20GasParameters<
+			chain,
+			account,
+			chainOverride
+		>,
+	) => Promise<EstimateInitiateERC20WithdrawalGasReturnType>;
+};
+
+export function publicActionsL2() {
+	return <
+		transport extends Transport,
+		chain extends Chain | undefined = Chain | undefined,
+		account extends Account | undefined = Account | undefined,
+	>(
+		client: Client<transport, chain, account>,
+	): PublicActionsL2<chain, account> => {
+		return {
+			buildProveWithdrawal: (args) => buildProveWithdrawal(client, args),
+			estimateInitiateMNTWithdrawalGas: (args) =>
+				estimateInitiateMNTWithdrawalGas(client, args),
+			estimateInitiateETHWithdrawalGas: (args) =>
+				estimateInitiateETHWithdrawalGas(client, args),
+			estimateInitiateERC20Withdrawal: (args) =>
+				estimateInitiateERC20Withdrawal(client, args),
+		};
+	};
+}

package/src/mantle/decorators/walletL1.ts

@@ -0,0 +1,67 @@
+import type { Client, Transport } from "viem";
+import type { Chain } from "viem";
+import type { Account } from "viem";
+import {
+	depositERC20,
+	type DepositERC20Parameters,
+	type DepositERC20ReturnType,
+} from "../actions/depositERC20.js";
+import {
+	depositETH,
+	type DepositETHParameters,
+	type DepositETHReturnType,
+} from "../actions/depositETH.js";
+import {
+	depositMNT,
+	type DepositMNTParameters,
+	type DepositMNTReturnType,
+} from "../actions/depositMNT.js";
+import {
+	finalizeWithdrawal,
+	type FinalizeWithdrawalParameters,
+	type FinalizeWithdrawalReturnType,
+} from "../actions/finalizeWithdrawal.js";
+import {
+	proveWithdrawal,
+	type ProveWithdrawalParameters,
+	type ProveWithdrawalReturnType,
+} from "../actions/proveWithdrawal.js";
+
+export type WalletActionsL1<
+	chain extends Chain | undefined = Chain | undefined,
+	account extends Account | undefined = Account | undefined,
+> = {
+	depositMNT: <chainOverride extends Chain | undefined = Chain | undefined>(
+		args: DepositMNTParameters<chain, account, chainOverride>,
+	) => Promise<DepositMNTReturnType>;
+	depositERC20: <chainOverride extends Chain | undefined = Chain | undefined>(
+		args: DepositERC20Parameters<chain, account, chainOverride>,
+	) => Promise<DepositERC20ReturnType>;
+	depositETH: <chainOverride extends Chain | undefined = Chain | undefined>(
+		args: DepositETHParameters<chain, account, chainOverride>,
+	) => Promise<DepositETHReturnType>;
+	finalizeWithdrawal: <chainOverride extends Chain | undefined = undefined>(
+		parameters: FinalizeWithdrawalParameters<chain, account, chainOverride>,
+	) => Promise<FinalizeWithdrawalReturnType>;
+	proveWithdrawal: <chainOverride extends Chain | undefined = undefined>(
+		parameters: ProveWithdrawalParameters<chain, account, chainOverride>,
+	) => Promise<ProveWithdrawalReturnType>;
+};
+
+export function walletActionsL1() {
+	return <
+		transport extends Transport,
+		chain extends Chain | undefined = Chain | undefined,
+		account extends Account | undefined = Account | undefined,
+	>(
+		client: Client<transport, chain, account>,
+	): WalletActionsL1<chain, account> => {
+		return {
+			depositMNT: (args) => depositMNT(client, args),
+			depositERC20: (args) => depositERC20(client, args),
+			depositETH: (args) => depositETH(client, args),
+			finalizeWithdrawal: (args) => finalizeWithdrawal(client, args),
+			proveWithdrawal: (args) => proveWithdrawal(client, args),
+		};
+	};
+}

package/src/mantle/decorators/walletL2.ts

@@ -0,0 +1,55 @@
+import type { Client, Transport } from "viem";
+import type { Chain } from "viem";
+import type { Account } from "viem";
+import {
+	initiateERC20Withdrawal,
+	type InitiateERC20WithdrawalParameters,
+	type InitiateERC20WithdrawalReturnType,
+} from "../actions/initiateERC20Withdrawal.js";
+import {
+	initiateETHWithdrawal,
+	type InitiateETHWithdrawalParameters,
+	type InitiateETHWithdrawalReturnType,
+} from "../actions/initiateETHWithdrawal.js";
+import {
+	initiateMNTWithdrawal,
+	type InitiateMNTWithdrawalParameters,
+	type InitiateMNTWithdrawalReturnType,
+} from "../actions/initiateMNTWithdrawal.js";
+
+export type WalletActionsL2<
+	chain extends Chain | undefined = Chain | undefined,
+	account extends Account | undefined = Account | undefined,
+> = {
+	initiateMNTWithdrawal: <chainOverride extends Chain | undefined = undefined>(
+		parameters: InitiateMNTWithdrawalParameters<chain, account, chainOverride>,
+	) => Promise<InitiateMNTWithdrawalReturnType>;
+	initiateETHWithdrawal: <chainOverride extends Chain | undefined = undefined>(
+		parameters: InitiateETHWithdrawalParameters<chain, account, chainOverride>,
+	) => Promise<InitiateETHWithdrawalReturnType>;
+	initiateERC20Withdrawal: <
+		chainOverride extends Chain | undefined = undefined,
+	>(
+		parameters: InitiateERC20WithdrawalParameters<
+			chain,
+			account,
+			chainOverride
+		>,
+	) => Promise<InitiateERC20WithdrawalReturnType>;
+};
+
+export function walletActionsL2() {
+	return <
+		transport extends Transport,
+		chain extends Chain | undefined = Chain | undefined,
+		account extends Account | undefined = Account | undefined,
+	>(
+		client: Client<transport, chain, account>,
+	): WalletActionsL2<chain, account> => {
+		return {
+			initiateMNTWithdrawal: (args) => initiateMNTWithdrawal(client, args),
+			initiateETHWithdrawal: (args) => initiateETHWithdrawal(client, args),
+			initiateERC20Withdrawal: (args) => initiateERC20Withdrawal(client, args),
+		};
+	};
+}

package/src/mantle/errors/utils.ts

@@ -0,0 +1 @@
+export type ErrorType<name extends string = "Error"> = Error & { name: name };

package/src/mantle/errors/withdrawal.ts

@@ -0,0 +1,24 @@
+import { BaseError } from "viem";
+import type { Hex } from "viem";
+
+export type GameNotFoundErrorType = GameNotFoundError & {
+	name: "GameNotFoundError";
+};
+export class GameNotFoundError extends BaseError {
+	constructor() {
+		super("Dispute game not found.", { name: "GameNotFoundError" });
+	}
+}
+
+export type ReceiptContainsNoWithdrawalsErrorType =
+	ReceiptContainsNoWithdrawalsError & {
+		name: "ReceiptContainsNoWithdrawalsError";
+	};
+export class ReceiptContainsNoWithdrawalsError extends BaseError {
+	constructor({ hash }: { hash: Hex }) {
+		super(
+			`The provided transaction receipt with hash "${hash}" contains no withdrawals.`,
+			{ name: "ReceiptContainsNoWithdrawalsError" },
+		);
+	}
+}