@mantleio/viem 0.0.1-alpha.0

package/src/mantle/types/transaction.ts

@@ -0,0 +1,108 @@
+import type { FeeValuesEIP1559 } from "viem";
+import type { Hex } from "viem";
+import type {
+	Index,
+	Quantity,
+	RpcTransaction as RpcTransaction_,
+	RpcTransactionReceipt,
+} from "viem";
+import type {
+	Transaction as Transaction_,
+	TransactionBase,
+	TransactionReceipt,
+	TransactionSerializable,
+	TransactionSerializableBase,
+	TransactionSerialized,
+	TransactionType,
+} from "viem";
+import type { OneOf } from "viem";
+
+type RpcTransaction<pending extends boolean = boolean> =
+	RpcTransaction_<pending> & {
+		isSystemTx?: undefined;
+		mint?: undefined;
+		sourceHash?: undefined;
+	};
+
+export type OpStackRpcDepositTransaction<pending extends boolean = boolean> =
+	Omit<TransactionBase<Quantity, Index, pending>, "typeHex"> &
+		FeeValuesEIP1559<Quantity> & {
+			isSystemTx?: boolean | undefined;
+			mint?: Hex | undefined;
+			sourceHash: Hex;
+			type: "0x7e";
+		};
+export type OpStackRpcTransaction<pending extends boolean = boolean> = OneOf<
+	RpcTransaction<pending> | OpStackRpcDepositTransaction<pending>
+>;
+
+export type OpStackRpcTransactionReceiptOverrides = {
+	l1GasPrice: Hex | null;
+	l1GasUsed: Hex | null;
+	l1Fee: Hex | null;
+	l1FeeScalar: `${number}` | null;
+};
+export type OpStackRpcTransactionReceipt = RpcTransactionReceipt &
+	OpStackRpcTransactionReceiptOverrides;
+
+type Transaction<pending extends boolean = boolean> = Transaction_<
+	bigint,
+	number,
+	pending
+> & {
+	isSystemTx?: undefined;
+	mint?: undefined;
+	sourceHash?: undefined;
+};
+
+export type OpStackDepositTransaction<pending extends boolean = boolean> =
+	TransactionBase<bigint, number, pending> &
+		FeeValuesEIP1559 & {
+			isSystemTx?: boolean;
+			mint?: bigint | undefined;
+			sourceHash: Hex;
+			type: "deposit";
+		};
+
+export type OpStackTransaction<pending extends boolean = boolean> =
+	| Transaction<pending>
+	| OpStackDepositTransaction<pending>;
+
+export type OpStackTransactionReceiptOverrides = {
+	l1GasPrice: bigint | null;
+	l1GasUsed: bigint | null;
+	l1Fee: bigint | null;
+	l1FeeScalar: number | null;
+};
+export type OpStackTransactionReceipt = TransactionReceipt &
+	OpStackTransactionReceiptOverrides;
+
+export type OpStackTransactionSerializable = OneOf<
+	TransactionSerializableDeposit | TransactionSerializable
+>;
+
+export type OpStackTransactionSerialized<
+	type extends OpStackTransactionType = OpStackTransactionType,
+> = type extends "deposit"
+	? TransactionSerializedDeposit
+	: TransactionSerialized<type>;
+
+export type OpStackTransactionType = TransactionType | "deposit";
+
+export type TransactionSerializableDeposit<
+	quantity = bigint,
+	index = number,
+> = Omit<
+	TransactionSerializableBase<quantity, index>,
+	"nonce" | "r" | "s" | "v"
+> & {
+	from: Hex;
+	isSystemTx?: boolean;
+	mint?: bigint | undefined;
+	sourceHash: Hex;
+	type: "deposit";
+	ethValue?: bigint | undefined;
+	ethTxValue?: bigint | undefined;
+};
+
+export type TransactionSerializedDeposit = `0x7e${string}`;

package/src/mantle/types/withdrawal.ts

@@ -0,0 +1,45 @@
+import type { Address } from "viem";
+import type { Hex } from "viem";
+
+export type InitialteWithdrawalRequest = {
+	/** L2 Transaction recipient. */
+	// to: Address;
+	amount: bigint;
+	to?: Address;
+} & (
+	| {
+			type: "mnt" | "eth";
+			l2Token?: undefined;
+	  }
+	| {
+			type: "erc20";
+			/** Other ERC20 L2 Token Address. */
+			l2Token: Address;
+	  }
+);
+
+export type InitiateERC20WithdrawalRequest = {
+	amount: bigint;
+	/** Other ERC20 L2 Token Address. */
+	l2Token: Address;
+	to?: Address;
+};
+export type InitiateMNTWithdrawalRequest = {
+	amount: bigint;
+	to?: Address;
+};
+export type InitiateETHWithdrawalRequest = {
+	amount: bigint;
+	to?: Address;
+};
+
+export type Withdrawal = {
+	nonce: bigint;
+	sender: Hex;
+	target: Hex;
+	mntValue: bigint;
+	ethValue: bigint;
+	gasLimit: bigint;
+	data: Hex;
+	withdrawalHash: Hex;
+};

package/src/mantle/utils/extractTransactionDepositedLogs.ts

@@ -0,0 +1,33 @@
+import { parseEventLogs, type ParseEventLogsErrorType } from "viem";
+import type { Log } from "viem";
+import { portalAbi } from "../abis.js";
+import type { ErrorType } from "../errors/utils.js";
+
+export type ExtractTransactionDepositedLogsParameters = {
+	/** An opaque array of logs. */
+	logs: Log[];
+};
+
+export type ExtractTransactionDepositedLogsReturnType = Log<
+	bigint,
+	number,
+	false,
+	undefined,
+	true,
+	typeof portalAbi,
+	"TransactionDeposited"
+>[];
+
+export type ExtractTransactionDepositedLogsErrorType =
+	| ParseEventLogsErrorType
+	| ErrorType;
+
+export function extractTransactionDepositedLogs({
+	logs,
+}: ExtractTransactionDepositedLogsParameters) {
+	return parseEventLogs({
+		abi: portalAbi,
+		eventName: "TransactionDeposited",
+		logs,
+	});
+}

package/src/mantle/utils/extractWithdrawalMessageLogs.ts

@@ -0,0 +1,33 @@
+import { parseEventLogs, type ParseEventLogsErrorType } from "viem";
+import type { Log } from "viem";
+import { l2ToL1MessagePasserAbi } from "../abis.js";
+import type { ErrorType } from "../errors/utils.js";
+
+export type ExtractWithdrawalMessageLogsParameters = {
+	/** An opaque array of logs. */
+	logs: Log[];
+};
+
+export type ExtractWithdrawalMessageLogsReturnType = Log<
+	bigint,
+	number,
+	false,
+	undefined,
+	true,
+	typeof l2ToL1MessagePasserAbi,
+	"MessagePassed"
+>[];
+
+export type ExtractWithdrawalMessageLogsErrorType =
+	| ParseEventLogsErrorType
+	| ErrorType;
+
+export function extractWithdrawalMessageLogs({
+	logs,
+}: ExtractWithdrawalMessageLogsParameters) {
+	return parseEventLogs({
+		abi: l2ToL1MessagePasserAbi,
+		eventName: "MessagePassed",
+		logs,
+	});
+}

package/src/mantle/utils/getL2TransactionHash.ts

@@ -0,0 +1,51 @@
+import { keccak256 } from "viem";
+import type { Log } from "viem";
+import type { Hex } from "viem";
+import type { portalAbi } from "../abis.js";
+import type { ErrorType } from "../errors/utils.js";
+import { serializeTransaction } from "../serializers.js";
+import { getSourceHash } from "./getSourceHash.js";
+import { opaqueDataToDepositData } from "./opaqueDataToDepositData.js";
+
+export type GetL2TransactionHashParameters = {
+	/** The "TransactionDeposited" log to compute the L2 hash from. */
+	log: Log<
+		bigint,
+		number,
+		false,
+		undefined,
+		true,
+		typeof portalAbi,
+		"TransactionDeposited"
+	>;
+};
+
+export type GetL2TransactionHashReturnType = Hex;
+
+export type GetL2TransactionHashErrorType = ErrorType;
+
+export function getL2TransactionHash({ log }: GetL2TransactionHashParameters) {
+	const sourceHash = getSourceHash({
+		domain: "userDeposit",
+		l1BlockHash: log.blockHash,
+		l1LogIndex: log.logIndex,
+	});
+	const { data, gas, isCreation, mint, value, ethValue, ethTxValue } =
+		opaqueDataToDepositData(log.args.opaqueData);
+
+	return keccak256(
+		serializeTransaction({
+			from: log.args.from,
+			to: isCreation ? undefined : log.args.to,
+			sourceHash,
+			data,
+			gas,
+			isSystemTx: false,
+			mint,
+			type: "deposit",
+			value,
+			ethValue,
+			ethTxValue,
+		}),
+	);
+}

package/src/mantle/utils/getL2TransactionHashes.ts

@@ -0,0 +1,21 @@
+import type { Log } from "viem";
+import type { Hex } from "viem";
+import type { ErrorType } from "../errors/utils.js";
+import { extractTransactionDepositedLogs } from "./extractTransactionDepositedLogs.js";
+import { getL2TransactionHash } from "./getL2TransactionHash.js";
+
+export type GetL2TransactionHashesParameters = {
+	/** The L1 transaction receipt logs. */
+	logs: Log[];
+};
+
+export type GetL2TransactionHashesReturnType = Hex[];
+
+export type GetL2TransactionHashesErrorType = ErrorType;
+
+export function getL2TransactionHashes({
+	logs,
+}: GetL2TransactionHashesParameters): GetL2TransactionHashesReturnType {
+	const extractedLogs = extractTransactionDepositedLogs({ logs });
+	return extractedLogs.map((log) => getL2TransactionHash({ log }));
+}

package/src/mantle/utils/getSourceHash.ts

@@ -0,0 +1,62 @@
+import {
+	concat,
+	type ConcatErrorType,
+	keccak256,
+	type Keccak256ErrorType,
+	pad,
+	type PadErrorType,
+	toHex,
+	type ToHexErrorType,
+} from "viem";
+import type { Hex } from "viem";
+import type { ErrorType } from "../errors/utils.js";
+
+export type GetSourceHashParameters = {
+	/** The L1 block hash. */
+	l1BlockHash: Hex;
+} & (
+	| {
+			/** Domain of source hash. */
+			domain: "userDeposit";
+			/** The index of the log on the L1. */
+			l1LogIndex: number;
+			/** The sequence number. */
+			sequenceNumber?: undefined;
+	  }
+	| {
+			/** Domain of source hash. */
+			domain: "l1InfoDeposit";
+			/** The index of the log on the L1. */
+			l1LogIndex?: undefined;
+			/** The sequence number. */
+			sequenceNumber: number;
+	  }
+);
+
+export type GetSourceHashReturnType = Hex;
+
+export type GetSourceHashErrorType =
+	| ConcatErrorType
+	| Keccak256ErrorType
+	| PadErrorType
+	| ToHexErrorType
+	| ErrorType;
+
+const sourceHashDomainMap = {
+	userDeposit: 0,
+	l1InfoDeposit: 1,
+} as const;
+
+export function getSourceHash({
+	domain,
+	l1LogIndex,
+	l1BlockHash,
+	sequenceNumber,
+}: GetSourceHashParameters) {
+	const marker = toHex(l1LogIndex! ?? sequenceNumber!);
+	const input = concat([l1BlockHash, pad(marker, { size: 32 })]);
+	const depositIdHash = keccak256(input);
+	const domainHex = toHex(sourceHashDomainMap[domain]);
+	const domainInput = concat([pad(domainHex, { size: 32 }), depositIdHash]);
+	return keccak256(domainInput);
+}

package/src/mantle/utils/getWithdrawalHashStorageSlot.ts

@@ -0,0 +1,27 @@
+import {
+	encodeAbiParameters,
+	type EncodeAbiParametersErrorType,
+	keccak256,
+	type Keccak256ErrorType,
+} from "viem";
+import type { Hash } from "viem";
+import type { ErrorType } from "../errors/utils.js";
+
+export type GetWithdrawalHashStorageSlotParameters = {
+	withdrawalHash: Hash;
+};
+export type GetWithdrawalHashStorageSlotReturnType = Hash;
+export type GetWithdrawalHashStorageSlotErrorType =
+	| EncodeAbiParametersErrorType
+	| Keccak256ErrorType
+	| ErrorType;
+
+export function getWithdrawalHashStorageSlot({
+	withdrawalHash,
+}: GetWithdrawalHashStorageSlotParameters) {
+	const data = encodeAbiParameters(
+		[{ type: "bytes32" }, { type: "uint256" }],
+		[withdrawalHash, 0n],
+	);
+	return keccak256(data);
+}

package/src/mantle/utils/getWithdrawals.ts

@@ -0,0 +1,25 @@
+import type { Log } from "viem";
+import type { ErrorType } from "../errors/utils.js";
+import type { Withdrawal } from "../types/withdrawal.js";
+import {
+	extractWithdrawalMessageLogs,
+	type ExtractWithdrawalMessageLogsErrorType,
+} from "./extractWithdrawalMessageLogs.js";
+
+export type GetWithdrawalsParameters = {
+	/** The L2 transaction receipt logs. */
+	logs: Log[];
+};
+
+export type GetWithdrawalsReturnType = Withdrawal[];
+
+export type GetWithdrawalsErrorType =
+	| ExtractWithdrawalMessageLogsErrorType
+	| ErrorType;
+
+export function getWithdrawals({
+	logs,
+}: GetWithdrawalsParameters): GetWithdrawalsReturnType {
+	const extractedLogs = extractWithdrawalMessageLogs({ logs });
+	return extractedLogs.map((log) => log.args);
+}

package/src/mantle/utils/opaqueDataToDepositData.ts

@@ -0,0 +1,58 @@
+import {
+	hexToBigInt,
+	size,
+	type SizeErrorType,
+	slice,
+	type SliceErrorType,
+} from "viem";
+import type { Hex } from "viem";
+import type { ErrorType } from "../errors/utils.js";
+
+export type OpaqueDataToDepositDataParameters = Hex;
+
+export type OpaqueDataToDepositDataReturnType = {
+	mint: bigint;
+	value: bigint;
+	gas: bigint;
+	isCreation: boolean;
+	data: Hex;
+	ethValue: bigint;
+	ethTxValue: bigint;
+};
+
+export type OpaqueDataToDepositDataErrorType =
+	| SliceErrorType
+	| SizeErrorType
+	| ErrorType;
+
+export function opaqueDataToDepositData(
+	opaqueData: Hex,
+): OpaqueDataToDepositDataReturnType {
+	let offset = 0;
+	const mint = slice(opaqueData, offset, offset + 32);
+	offset += 32;
+	const value = slice(opaqueData, offset, offset + 32);
+	offset += 32;
+	const ethValue = slice(opaqueData, offset, offset + 32);
+	offset += 32;
+	const ethTxValue = slice(opaqueData, offset, offset + 32);
+	offset += 32;
+	const gas = slice(opaqueData, offset, offset + 8);
+	offset += 8;
+	const isCreation =
+		BigInt(slice(opaqueData, offset, offset + 1)) === BigInt(1);
+	offset += 1;
+	const data =
+		offset > size(opaqueData) - 1
+			? "0x"
+			: slice(opaqueData, offset, opaqueData.length);
+	return {
+		mint: hexToBigInt(mint),
+		value: hexToBigInt(value),
+		gas: hexToBigInt(gas),
+		isCreation,
+		data,
+		ethValue: hexToBigInt(ethValue),
+		ethTxValue: hexToBigInt(ethTxValue),
+	};
+}

package/src/mantle/utils/parseDepositRequest.ts

@@ -0,0 +1,67 @@
+import type { Address, Hex } from "viem";
+import type { DepositRequest } from "../types/deposit.js";
+
+export type DepositFunctionName =
+	| "depositETH"
+	| "depositERC20"
+	| "depositMNT"
+	| "depositETHTo"
+	| "depositERC20To"
+	| "depositMNTTo";
+export type DepositArgs =
+	| [number, Hex]
+	| [Address, Address, bigint, number, Hex]
+	| [bigint, number, Hex]
+	| [Address, number, Hex]
+	| [Address, Address, Address, bigint, number, Hex]
+	| [Address, bigint, number, Hex];
+type ParseDepositRequestReturnType = {
+	functionName: DepositFunctionName;
+	args: DepositArgs;
+};
+
+export const parseDepositRequest = ({
+	type,
+	l1Token,
+	l2Token,
+	amount,
+	to,
+}: DepositRequest): ParseDepositRequestReturnType => {
+	if (to) {
+		switch (type) {
+			case "eth":
+				return {
+					functionName: "depositETHTo",
+					args: [to, 200000, "0x"],
+				};
+			case "erc20":
+				return {
+					functionName: "depositERC20To",
+					args: [l1Token, l2Token, to, amount, 200000, "0x"],
+				};
+			default:
+				return {
+					functionName: "depositMNTTo",
+					args: [to, amount, 200000, "0x"],
+				};
+		}
+	}
+
+	switch (type) {
+		case "eth":
+			return {
+				functionName: "depositETH",
+				args: [200000, "0x"],
+			};
+		case "erc20":
+			return {
+				functionName: "depositERC20",
+				args: [l1Token, l2Token, amount, 200000, "0x"],
+			};
+		default:
+			return {
+				functionName: "depositMNT",
+				args: [amount, 200000, "0x"],
+			};
+	}
+};

package/src/mantle/utils/parseInitWithdrawRequest.ts

@@ -0,0 +1,68 @@
+import type { Address, Hex } from "viem";
+import type { InitialteWithdrawalRequest } from "../types/withdrawal.js";
+
+export type InitWithdrawFunctionName = "withdraw" | "withdrawTo";
+export type WithdrawArgs =
+	| [Address, bigint, number, Hex]
+	| [Address, Address, bigint, number, Hex];
+type ParseWithdrawRequestReturnType = {
+	functionName: InitWithdrawFunctionName;
+	args: WithdrawArgs;
+};
+
+export const parseInitWithdrawequest = ({
+	type,
+	l2Token,
+	amount,
+	to,
+}: InitialteWithdrawalRequest): ParseWithdrawRequestReturnType => {
+	if (to) {
+		switch (type) {
+			case "eth":
+				return {
+					functionName: "withdrawTo",
+					args: [
+						"0xdeaddeaddeaddeaddeaddeaddeaddeaddead1111",
+						to,
+						amount,
+						0,
+						"0x",
+					],
+				};
+			case "erc20":
+				return {
+					functionName: "withdrawTo",
+					args: [l2Token, to, amount, 0, "0x"],
+				};
+			default:
+				return {
+					functionName: "withdrawTo",
+					args: [
+						"0x0000000000000000000000000000000000000000",
+						to,
+						amount,
+						0,
+						"0x",
+					],
+				};
+		}
+	}
+
+	switch (type) {
+		case "eth":
+			return {
+				functionName: "withdraw",
+				args: ["0xdeaddeaddeaddeaddeaddeaddeaddeaddead1111", amount, 0, "0x"],
+			};
+		case "erc20":
+			return {
+				functionName: "withdraw",
+				args: [l2Token, amount, 0, "0x"],
+			};
+		default:
+			return {
+				functionName: "withdraw",
+				args: ["0x0000000000000000000000000000000000000000", amount, 0, "0x"],
+			};
+	}
+};

package/src/mantle/utils/poll.ts

@@ -0,0 +1,45 @@
+import type { ErrorType } from "../errors/utils.js";
+import { wait } from "./wait.js";
+
+type PollOptions<data> = {
+	// Whether or not to emit when the polling starts.
+	emitOnBegin?: boolean | undefined;
+	// The initial wait time (in ms) before polling.
+	initialWaitTime?: ((data: data | void) => Promise<number>) | undefined;
+	// The interval (in ms).
+	interval: number;
+};
+
+export type PollErrorType = ErrorType;
+
+/**
+ * @description Polls a function at a specified interval.
+ */
+export function poll<data>(
+	fn: ({ unpoll }: { unpoll: () => void }) => Promise<data | void>,
+	{ emitOnBegin, initialWaitTime, interval }: PollOptions<data>,
+) {
+	let active = true;
+
+	const unwatch = () => (active = false);
+
+	const watch = async () => {
+		let data: data | void = undefined;
+		if (emitOnBegin) data = await fn({ unpoll: unwatch });
+
+		const initialWait = (await initialWaitTime?.(data)) ?? interval;
+		await wait(initialWait);
+
+		const poll = async () => {
+			if (!active) return;
+			await fn({ unpoll: unwatch });
+			await wait(interval);
+			poll();
+		};
+
+		poll();
+	};
+	watch();
+
+	return unwatch;
+}