@mantleio/viem 0.0.1-alpha.0

package/src/mantle/formatters.ts

@@ -0,0 +1,64 @@
+import {
+	defineBlock,
+	defineTransaction,
+	defineTransactionReceipt,
+	formatTransaction,
+	hexToBigInt,
+} from "viem";
+import type { ChainFormatters } from "viem";
+import type { RpcTransaction } from "viem";
+import type { OpStackBlock, OpStackRpcBlock } from "./types/block.js";
+import type {
+	OpStackRpcTransaction,
+	OpStackRpcTransactionReceipt,
+	OpStackTransaction,
+	OpStackTransactionReceipt,
+} from "./types/transaction.js";
+
+export const formatters = {
+	block: /*#__PURE__*/ defineBlock({
+		format(args: OpStackRpcBlock): OpStackBlock {
+			const transactions = args.transactions?.map((transaction) => {
+				if (typeof transaction === "string") return transaction;
+				const formatted = formatTransaction(
+					transaction as RpcTransaction,
+				) as OpStackTransaction;
+				if (formatted.typeHex === "0x7e") {
+					formatted.isSystemTx = transaction.isSystemTx;
+					formatted.mint = transaction.mint
+						? hexToBigInt(transaction.mint)
+						: undefined;
+					formatted.sourceHash = transaction.sourceHash;
+					formatted.type = "deposit";
+				}
+				return formatted;
+			});
+			return {
+				transactions,
+				stateRoot: args.stateRoot,
+			} as OpStackBlock;
+		},
+	}),
+	transaction: /*#__PURE__*/ defineTransaction({
+		format(args: OpStackRpcTransaction): OpStackTransaction {
+			const transaction = {} as OpStackTransaction;
+			if (args.type === "0x7e") {
+				transaction.isSystemTx = args.isSystemTx;
+				transaction.mint = args.mint ? hexToBigInt(args.mint) : undefined;
+				transaction.sourceHash = args.sourceHash;
+				transaction.type = "deposit";
+			}
+			return transaction;
+		},
+	}),
+	transactionReceipt: /*#__PURE__*/ defineTransactionReceipt({
+		format(args: OpStackRpcTransactionReceipt): OpStackTransactionReceipt {
+			return {
+				l1GasPrice: args.l1GasPrice ? hexToBigInt(args.l1GasPrice) : null,
+				l1GasUsed: args.l1GasUsed ? hexToBigInt(args.l1GasUsed) : null,
+				l1Fee: args.l1Fee ? hexToBigInt(args.l1Fee) : null,
+				l1FeeScalar: args.l1FeeScalar ? Number(args.l1FeeScalar) : null,
+			} as OpStackTransactionReceipt;
+		},
+	}),
+} as const satisfies ChainFormatters;

package/src/mantle/index.ts

@@ -0,0 +1,179 @@
+// biome-ignore lint/performance/noBarrelFile: entrypoint module
+export {
+	buildProveWithdrawal,
+	type BuildProveWithdrawalErrorType,
+	type BuildProveWithdrawalParameters,
+	type BuildProveWithdrawalReturnType,
+} from "./actions/buildProveWithdrawal.js";
+
+export {
+	finalizeWithdrawal,
+	type FinalizeWithdrawalErrorType,
+	type FinalizeWithdrawalParameters,
+	type FinalizeWithdrawalReturnType,
+} from "./actions/finalizeWithdrawal.js";
+export {
+	getL2Output,
+	type GetL2OutputErrorType,
+	type GetL2OutputParameters,
+	type GetL2OutputReturnType,
+} from "./actions/getL2Output.js";
+export {
+	getPortalVersion,
+	type GetPortalVersionErrorType,
+	type GetPortalVersionParameters,
+	type GetPortalVersionReturnType,
+} from "./actions/getPortalVersion.js";
+export {
+	getTimeToFinalize,
+	type GetTimeToFinalizeErrorType,
+	type GetTimeToFinalizeParameters,
+	type GetTimeToFinalizeReturnType,
+} from "./actions/getTimeToFinalize.js";
+export {
+	getTimeToNextL2Output,
+	type GetTimeToNextL2OutputErrorType,
+	type GetTimeToNextL2OutputParameters,
+	type GetTimeToNextL2OutputReturnType,
+} from "./actions/getTimeToNextL2Output.js";
+export {
+	getTimeToProve,
+	type GetTimeToProveErrorType,
+	type GetTimeToProveParameters,
+	type GetTimeToProveReturnType,
+} from "./actions/getTimeToProve.js";
+export {
+	getWithdrawalStatus,
+	type GetWithdrawalStatusErrorType,
+	type GetWithdrawalStatusParameters,
+	type GetWithdrawalStatusReturnType,
+} from "./actions/getWithdrawalStatus.js";
+export {
+	proveWithdrawal,
+	type ProveWithdrawalErrorType,
+	type ProveWithdrawalParameters,
+	type ProveWithdrawalReturnType,
+} from "./actions/proveWithdrawal.js";
+export {
+	waitForNextL2Output,
+	type WaitForNextL2OutputErrorType,
+	type WaitForNextL2OutputParameters,
+	type WaitForNextL2OutputReturnType,
+} from "./actions/waitForNextL2Output.js";
+export {
+	waitToFinalize,
+	type WaitToFinalizeErrorType,
+	type WaitToFinalizeParameters,
+	type WaitToFinalizeReturnType,
+} from "./actions/waitToFinalize.js";
+export {
+	waitToProve,
+	type WaitToProveErrorType,
+	type WaitToProveParameters,
+	type WaitToProveReturnType,
+} from "./actions/waitToProve.js";
+
+export { chainConfig } from "./chainConfig.js";
+
+export {
+	type PublicActionsL1,
+	publicActionsL1,
+} from "./decorators/publicL1.js";
+export {
+	type PublicActionsL2,
+	publicActionsL2,
+} from "./decorators/publicL2.js";
+export {
+	type WalletActionsL1,
+	walletActionsL1,
+} from "./decorators/walletL1.js";
+export {
+	type WalletActionsL2,
+	walletActionsL2,
+} from "./decorators/walletL2.js";
+
+export {
+	parseTransaction,
+	type ParseTransactionErrorType,
+	type ParseTransactionReturnType,
+} from "./parsers.js";
+
+export {
+	serializers,
+	serializeTransaction,
+	type SerializeTransactionErrorType,
+	type SerializeTransactionReturnType,
+} from "./serializers.js";
+
+export type {
+	OpStackBlock,
+	OpStackBlockOverrides,
+	OpStackRpcBlock,
+	OpStackRpcBlockOverrides,
+} from "./types/block.js";
+export type {
+	OpStackDepositTransaction,
+	OpStackRpcDepositTransaction,
+	OpStackRpcTransaction,
+	OpStackRpcTransactionReceipt,
+	OpStackRpcTransactionReceiptOverrides,
+	OpStackTransaction,
+	OpStackTransactionReceipt,
+	OpStackTransactionReceiptOverrides,
+} from "./types/transaction.js";
+
+export {
+	extractWithdrawalMessageLogs,
+	type ExtractWithdrawalMessageLogsErrorType,
+	type ExtractWithdrawalMessageLogsParameters,
+	type ExtractWithdrawalMessageLogsReturnType,
+} from "./utils/extractWithdrawalMessageLogs.js";
+
+export {
+	extractTransactionDepositedLogs,
+	type ExtractTransactionDepositedLogsErrorType,
+	type ExtractTransactionDepositedLogsParameters,
+	type ExtractTransactionDepositedLogsReturnType,
+} from "./utils/extractTransactionDepositedLogs.js";
+
+export {
+	opaqueDataToDepositData,
+	type OpaqueDataToDepositDataErrorType,
+	type OpaqueDataToDepositDataParameters,
+	type OpaqueDataToDepositDataReturnType,
+} from "./utils/opaqueDataToDepositData.js";
+
+export {
+	getL2TransactionHash,
+	type GetL2TransactionHashErrorType,
+	type GetL2TransactionHashParameters,
+	type GetL2TransactionHashReturnType,
+} from "./utils/getL2TransactionHash.js";
+
+export {
+	getL2TransactionHashes,
+	type GetL2TransactionHashesErrorType,
+	type GetL2TransactionHashesParameters,
+	type GetL2TransactionHashesReturnType,
+} from "./utils/getL2TransactionHashes.js";
+
+export {
+	getSourceHash,
+	type GetSourceHashErrorType,
+	type GetSourceHashParameters,
+	type GetSourceHashReturnType,
+} from "./utils/getSourceHash.js";
+
+export {
+	getWithdrawalHashStorageSlot,
+	type GetWithdrawalHashStorageSlotErrorType,
+	type GetWithdrawalHashStorageSlotParameters,
+	type GetWithdrawalHashStorageSlotReturnType,
+} from "./utils/getWithdrawalHashStorageSlot.js";
+
+export {
+	getWithdrawals,
+	type GetWithdrawalsErrorType,
+	type GetWithdrawalsParameters,
+	type GetWithdrawalsReturnType,
+} from "./utils/getWithdrawals.js";

package/src/mantle/parsers.ts

@@ -0,0 +1,97 @@
+import {
+	fromRlp,
+	type GetSerializedTransactionType,
+	type Hex,
+	hexToBigInt,
+	hexToBool,
+	isHex,
+	parseTransaction as parseTransaction_,
+	type ParseTransactionErrorType as ParseTransactionErrorType_,
+	type ParseTransactionReturnType as ParseTransactionReturnType_,
+	sliceHex,
+} from "viem";
+import { InvalidSerializedTransactionError } from "viem";
+import type { ErrorType } from "./errors/utils.js";
+import { assertTransactionDeposit } from "./serializers.js";
+import type {
+	OpStackTransactionSerialized,
+	OpStackTransactionType,
+	TransactionSerializableDeposit,
+	TransactionSerializedDeposit,
+} from "./types/transaction.js";
+
+export function toTransactionArray(serializedTransaction: string) {
+	return fromRlp(`0x${serializedTransaction.slice(4)}` as Hex, "hex");
+}
+
+export type ParseTransactionReturnType<
+	serialized extends
+		OpStackTransactionSerialized = OpStackTransactionSerialized,
+	type extends
+		OpStackTransactionType = GetSerializedTransactionType<serialized>,
+> = serialized extends TransactionSerializedDeposit
+	? TransactionSerializableDeposit
+	: ParseTransactionReturnType_<serialized, type>;
+
+export type ParseTransactionErrorType = ParseTransactionErrorType_ | ErrorType;
+
+export function parseTransaction<
+	serialized extends OpStackTransactionSerialized,
+>(serializedTransaction: serialized): ParseTransactionReturnType<serialized> {
+	const serializedType = sliceHex(serializedTransaction, 0, 1);
+
+	if (serializedType === "0x7e") {
+		return parseTransactionDeposit(
+			serializedTransaction as TransactionSerializedDeposit,
+		) as ParseTransactionReturnType<serialized>;
+	}
+
+	return parseTransaction_(
+		serializedTransaction,
+	) as ParseTransactionReturnType<serialized>;
+}
+
+function parseTransactionDeposit(
+	serializedTransaction: TransactionSerializedDeposit,
+): ParseTransactionReturnType<TransactionSerializedDeposit> {
+	const transactionArray = toTransactionArray(serializedTransaction);
+
+	const [sourceHash, from, to, mint, value, gas, isSystemTx, data] =
+		transactionArray;
+
+	if (transactionArray.length !== 8 || !isHex(sourceHash) || !isHex(from)) {
+		throw new InvalidSerializedTransactionError({
+			attributes: {
+				sourceHash,
+				from,
+				gas,
+				to,
+				mint,
+				value,
+				isSystemTx,
+				data,
+			},
+			serializedTransaction,
+			type: "deposit",
+		});
+	}
+
+	const transaction: TransactionSerializableDeposit = {
+		sourceHash,
+		from,
+		type: "deposit",
+	};
+
+	if (isHex(gas) && gas !== "0x") transaction.gas = hexToBigInt(gas);
+	if (isHex(to) && to !== "0x") transaction.to = to;
+	if (isHex(mint) && mint !== "0x") transaction.mint = hexToBigInt(mint);
+	if (isHex(value) && value !== "0x") transaction.value = hexToBigInt(value);
+	if (isHex(isSystemTx) && isSystemTx !== "0x") {
+		transaction.isSystemTx = hexToBool(isSystemTx);
+	}
+	if (isHex(data) && data !== "0x") transaction.data = data;
+
+	assertTransactionDeposit(transaction);
+
+	return transaction;
+}

package/src/mantle/serializers.ts

@@ -0,0 +1,106 @@
+import {
+	concatHex,
+	isAddress,
+	serializeTransaction as serializeTransaction_,
+	type SerializeTransactionErrorType as SerializeTransactionErrorType_,
+	toHex,
+	toRlp,
+} from "viem";
+import { InvalidAddressError } from "viem";
+import type { ChainSerializers } from "viem";
+import type { Hex, Signature } from "viem";
+import type { TransactionSerializable } from "viem";
+import type { RequiredBy } from "viem";
+import type { ErrorType } from "./errors/utils.js";
+import type {
+	OpStackTransactionSerializable,
+	TransactionSerializableDeposit,
+	TransactionSerializedDeposit,
+} from "./types/transaction.js";
+
+export type SerializeTransactionReturnType = ReturnType<
+	typeof serializeTransaction
+>;
+
+export type SerializeTransactionErrorType =
+	| SerializeTransactionErrorType_
+	| ErrorType;
+
+export function serializeTransaction(
+	transaction: OpStackTransactionSerializable,
+	signature?: Signature,
+) {
+	if (isDeposit(transaction)) return serializeTransactionDeposit(transaction);
+	return serializeTransaction_(
+		transaction as TransactionSerializable,
+		signature,
+	);
+}
+
+export const serializers = {
+	transaction: serializeTransaction,
+} as const satisfies ChainSerializers;
+
+//////////////////////////////////////////////////////////////////////////////
+// Serializers
+
+export type SerializeTransactionDepositReturnType =
+	TransactionSerializedDeposit;
+
+function serializeTransactionDeposit(
+	transaction: TransactionSerializableDeposit,
+): SerializeTransactionDepositReturnType {
+	assertTransactionDeposit(transaction);
+
+	const {
+		sourceHash,
+		data,
+		from,
+		gas,
+		isSystemTx,
+		mint,
+		to,
+		value,
+		ethValue,
+		ethTxValue,
+	} = transaction;
+
+	const serializedTransaction: Hex[] = [
+		sourceHash,
+		from,
+		to ?? "0x",
+		mint ? toHex(mint) : "0x",
+		value ? toHex(value) : "0x",
+		gas ? toHex(gas) : "0x",
+		isSystemTx ? "0x1" : "0x",
+		ethValue ? toHex(ethValue) : "0x",
+		data ?? "0x",
+	];
+
+	if (ethTxValue) {
+		serializedTransaction.push(toHex(ethTxValue));
+	}
+
+	return concatHex([
+		"0x7e",
+		toRlp(serializedTransaction),
+	]) as SerializeTransactionDepositReturnType;
+}
+
+function isDeposit(
+	transaction: OpStackTransactionSerializable,
+): transaction is RequiredBy<TransactionSerializableDeposit, "type"> {
+	if (transaction.type === "deposit") return true;
+	if (typeof transaction.sourceHash !== "undefined") return true;
+	return false;
+}
+
+export function assertTransactionDeposit(
+	transaction: TransactionSerializableDeposit,
+) {
+	const { from, to } = transaction;
+	if (from && !isAddress(from)) {
+		throw new InvalidAddressError({ address: from });
+	}
+	if (to && !isAddress(to)) throw new InvalidAddressError({ address: to });
+}

package/src/mantle/types/account.ts

@@ -0,0 +1,25 @@
+import type { Address } from "viem";
+
+import type { Account } from "viem";
+import type { IsUndefined, MaybeRequired } from "viem";
+
+export type GetAccountParameter<
+	account extends Account | undefined = Account | undefined,
+	accountOverride extends Account | Address | undefined = Account | Address,
+	required extends boolean = true,
+	nullish extends boolean = false,
+> = MaybeRequired<
+	{
+		account?:
+			| accountOverride
+			| Account
+			| Address
+			| (nullish extends true ? null : never)
+			| undefined;
+	},
+	IsUndefined<account> extends true
+		? required extends true
+			? true
+			: false
+		: false
+>;

package/src/mantle/types/block.ts

@@ -0,0 +1,34 @@
+import type { Block, BlockTag } from "viem";
+import type { Hash } from "viem";
+import type { RpcBlock } from "viem";
+import type {
+	OpStackRpcTransaction,
+	OpStackTransaction,
+} from "./transaction.js";
+
+export type OpStackBlockOverrides = {
+	stateRoot: Hash;
+};
+export type OpStackBlock<
+	includeTransactions extends boolean = boolean,
+	blockTag extends BlockTag = BlockTag,
+> = Block<
+	bigint,
+	includeTransactions,
+	blockTag,
+	OpStackTransaction<blockTag extends "pending" ? true : false>
+> &
+	OpStackBlockOverrides;
+
+export type OpStackRpcBlockOverrides = {
+	stateRoot: Hash;
+};
+export type OpStackRpcBlock<
+	blockTag extends BlockTag = BlockTag,
+	includeTransactions extends boolean = boolean,
+> = RpcBlock<
+	blockTag,
+	includeTransactions,
+	OpStackRpcTransaction<blockTag extends "pending" ? true : false>
+> &
+	OpStackRpcBlockOverrides;

package/src/mantle/types/chain.ts

@@ -0,0 +1,10 @@
+import type { Chain, ChainContract } from "viem";
+
+export type TargetChain<
+	chain extends Chain = Chain,
+	contractName extends string = string,
+> = {
+	contracts: {
+		[_ in contractName]: { [_ in chain["id"]]: ChainContract };
+	};
+};

package/src/mantle/types/contract.ts

@@ -0,0 +1,26 @@
+import type { Address } from "viem";
+
+import type { Chain } from "viem";
+import type { Prettify } from "viem";
+import type { TargetChain } from "./chain.js";
+
+export type GetContractAddressParameter<
+	chain extends Chain | undefined,
+	contractName extends string,
+> =
+	| (chain extends Chain
+			? Prettify<
+					{
+						targetChain: Prettify<TargetChain<chain, contractName>>;
+					} & {
+						[_ in `${contractName}Address`]?: undefined;
+					}
+				>
+			: never)
+	| Prettify<
+			{
+				targetChain?: undefined;
+			} & {
+				[_ in `${contractName}Address`]: Address;
+			}
+	  >;

package/src/mantle/types/deposit.ts

@@ -0,0 +1,40 @@
+import type { Address } from "viem";
+
+export type DepositRequest = {
+	/** L2 Transaction recipient. */
+	// to: Address;
+	amount: bigint;
+	to?: Address;
+} & (
+	| {
+			type: "mnt" | "eth";
+			/** Other ERC20 L1 Token Address. */
+			l1Token?: undefined;
+			/** Other ERC20 L2 Token Address. */
+			l2Token?: undefined;
+	  }
+	| {
+			type: "erc20";
+			/** Other ERC20 L1 Token Address. */
+			l1Token: Address;
+			/** Other ERC20 L2 Token Address. */
+			l2Token: Address;
+	  }
+);
+
+export type DepositERC20Request = {
+	amount: bigint;
+	/** Other ERC20 L1 Token Address. */
+	l1Token: Address;
+	/** Other ERC20 L2 Token Address. */
+	l2Token: Address;
+	to?: Address;
+};
+export type DepositMNTRequest = {
+	amount: bigint;
+	to?: Address;
+};
+export type DepositETHRequest = {
+	amount: bigint;
+	to?: Address;
+};

package/src/mantle/types/l1Actions.ts

@@ -0,0 +1,21 @@
+import type { Address, Hex } from "viem";
+import { l1StandardBridge } from "../abis.js";
+
+export const depositABI = l1StandardBridge;
+export const depositErc20Function = "depositERC20To";
+export const l1StandardBridgeName = "l1StandardBridge";
+
+export type DepositERC20Parameters = {
+	/** Gas limit for transaction execution on the L2. Default as 20000 */
+	minGasLimit?: bigint | undefined;
+	/** Value in wei of tokens to deposit. */
+	amount: bigint;
+	/** Extra data to include in the transaction. */
+	extraData?: Hex | undefined;
+	/** L2 Transaction recipient. */
+	to?: Address | undefined;
+	/** ERC20 L1 Token Address. */
+	l1Token: Address;
+	/** ERC20 L2 Token Address. */
+	l2Token: Address;
+};

package/src/mantle/types/l2Actions.ts

@@ -0,0 +1,6 @@
+import { type Address, zeroAddress } from "viem";
+
+export const parseWithdrawL2Token = (l2Token?: Address) => {
+	if (!l2Token) return zeroAddress;
+	return l2Token;
+};