@mantleio/viem 0.0.1-alpha.0

package/src/mantle/actions/buildProveWithdrawal.ts

@@ -0,0 +1,150 @@
+import type { Address } from "viem";
+import { type Client, fromRlp, keccak256, toRlp, type Transport } from "viem";
+import type { Account, DeriveAccount } from "viem";
+import type { Chain, DeriveChain, GetChainParameter } from "viem";
+import type { Hex } from "viem";
+import type { OneOf, Prettify } from "viem";
+import {
+	getBlock,
+	type GetBlockErrorType,
+	getProof,
+	type GetProofErrorType,
+} from "viem/actions";
+import { contracts } from "../contracts.js";
+import type { ErrorType } from "../errors/utils.js";
+import type { GetAccountParameter } from "../types/account.js";
+import type { Withdrawal } from "../types/withdrawal.js";
+import {
+	getWithdrawalHashStorageSlot,
+	type GetWithdrawalHashStorageSlotErrorType,
+} from "../utils/getWithdrawalHashStorageSlot.js";
+import type { GetL2OutputReturnType } from "./getL2Output.js";
+import type { ProveWithdrawalParameters } from "./proveWithdrawal.js";
+
+const outputRootProofVersion =
+	"0x0000000000000000000000000000000000000000000000000000000000000000" as const;
+
+export type BuildProveWithdrawalParameters<
+	chain extends Chain | undefined = Chain | undefined,
+	account extends Account | undefined = Account | undefined,
+	chainOverride extends Chain | undefined = Chain | undefined,
+	accountOverride extends Account | Address | undefined =
+		| Account
+		| Address
+		| undefined,
+	_derivedChain extends Chain | undefined = DeriveChain<chain, chainOverride>,
+> = GetAccountParameter<account, accountOverride, false> &
+	GetChainParameter<chain, chainOverride> & {
+		withdrawal: Withdrawal;
+	} & OneOf<{ output: GetL2OutputReturnType }>;
+
+export type BuildProveWithdrawalReturnType<
+	chain extends Chain | undefined = Chain | undefined,
+	account extends Account | undefined = Account | undefined,
+	chainOverride extends Chain | undefined = Chain | undefined,
+	accountOverride extends Account | Address | undefined =
+		| Account
+		| Address
+		| undefined,
+> = Prettify<
+	Pick<
+		ProveWithdrawalParameters,
+		"l2OutputIndex" | "outputRootProof" | "withdrawalProof" | "withdrawal"
+	> & {
+		account: DeriveAccount<account, accountOverride>;
+		targetChain: DeriveChain<chain, chainOverride>;
+	}
+>;
+
+export type BuildProveWithdrawalErrorType =
+	| GetBlockErrorType
+	| GetProofErrorType
+	| GetWithdrawalHashStorageSlotErrorType
+	| ErrorType;
+
+/**
+ * Builds the transaction that proves a withdrawal was initiated on an L2. Used in the Withdrawal flow.
+ *
+ * @param client - Client to use
+ * @param parameters - {@link BuildProveWithdrawalParameters}
+ * @returns The prove withdraw transaction request. {@link BuildProveWithdrawalReturnType}
+ */
+export async function buildProveWithdrawal<
+	chain extends Chain | undefined,
+	account extends Account | undefined,
+	chainOverride extends Chain | undefined = undefined,
+	accountOverride extends Account | Address | undefined = undefined,
+>(
+	client: Client<Transport, chain, account>,
+	args: BuildProveWithdrawalParameters<
+		chain,
+		account,
+		chainOverride,
+		accountOverride
+	>,
+): Promise<
+	BuildProveWithdrawalReturnType<chain, account, chainOverride, accountOverride>
+> {
+	const { account, chain = client.chain, output, withdrawal } = args;
+
+	const { withdrawalHash } = withdrawal;
+	const { l2BlockNumber } = output;
+
+	const slot = getWithdrawalHashStorageSlot({ withdrawalHash });
+	const [proof, block] = await Promise.all([
+		getProof(client, {
+			address: contracts.l2ToL1MessagePasser.address,
+			storageKeys: [slot],
+			blockNumber: l2BlockNumber,
+		}),
+		getBlock(client, {
+			blockNumber: l2BlockNumber,
+		}),
+	]);
+
+	return {
+		account,
+		l2OutputIndex: output?.outputIndex,
+		outputRootProof: {
+			latestBlockhash: block.hash,
+			messagePasserStorageRoot: proof.storageHash,
+			stateRoot: block.stateRoot,
+			version: outputRootProofVersion,
+		},
+		targetChain: chain,
+		withdrawalProof: maybeAddProofNode(
+			keccak256(slot),
+			proof.storageProof[0].proof,
+		),
+		withdrawal,
+	} as unknown as BuildProveWithdrawalReturnType<
+		chain,
+		account,
+		chainOverride,
+		accountOverride
+	>;
+}
+
+/** @internal */
+export function maybeAddProofNode(key: string, proof: readonly Hex[]) {
+	const lastProofRlp = proof[proof.length - 1];
+	const lastProof = fromRlp(lastProofRlp);
+	if (lastProof.length !== 17) return proof;
+
+	const modifiedProof = [...proof];
+	for (const item of lastProof) {
+		// Find any nodes located inside of the branch node.
+		if (!Array.isArray(item)) continue;
+		// Check if the key inside the node matches the key we're looking for. We remove the first
+		// two characters (0x) and then we remove one more character (the first nibble) since this
+		// is the identifier for the type of node we're looking at. In this case we don't actually
+		// care what type of node it is because a branch node would only ever be the final proof
+		// element if (1) it includes the leaf node we're looking for or (2) it stores the value
+		// within itself. If (1) then this logic will work, if (2) then this won't find anything
+		// and we won't append any proof elements, which is exactly what we would want.
+		const suffix = item[0].slice(3);
+		if (typeof suffix !== "string" || !key.endsWith(suffix)) continue;
+		modifiedProof.push(toRlp(item));
+	}
+	return modifiedProof;
+}

package/src/mantle/actions/depositERC20.ts

@@ -0,0 +1,103 @@
+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 { l1StandardBridge } 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 { DepositERC20Request } from "../types/deposit.js";
+import { parseDepositRequest } from "../utils/parseDepositRequest.js";
+
+export type DepositERC20Parameters<
+	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, "l1StandardBridge"> & {
+		/** L2 transaction request. */
+		request: DepositERC20Request;
+		/**
+		 * Gas limit for transaction execution on the L1.
+		 */
+		gas?: bigint | undefined;
+	};
+export type DepositERC20ReturnType = Hash;
+export type DepositERC20ErrorType = WriteContractErrorType | ErrorType;
+
+/**
+ * @param client - Client to use
+ * @param parameters - {@link DepositERC20Parameters}
+ * @returns The L1 transaction hash. {@link DepositERC20ReturnType}
+ */
+export async function depositERC20<
+	chain extends Chain | undefined,
+	account extends Account | undefined,
+	chainOverride extends Chain | undefined = undefined,
+>(
+	client: Client<Transport, chain, account>,
+	parameters: DepositERC20Parameters<chain, account, chainOverride>,
+) {
+	const {
+		account,
+		chain = client.chain,
+		gas,
+		maxFeePerGas,
+		maxPriorityFeePerGas,
+		nonce,
+		request: { l1Token, l2Token, amount, to },
+		targetChain,
+	} = parameters;
+
+	const l1StandardBridgeAddress = (() => {
+		if (parameters.l1StandardBridgeAddress) {
+			return parameters.l1StandardBridgeAddress;
+		}
+		if (chain) return targetChain!.contracts.l1StandardBridge[chain.id].address;
+		return Object.values(targetChain!.contracts.l1StandardBridge)[0].address;
+	})();
+
+	const { functionName, args } = parseDepositRequest({
+		type: "erc20",
+		l1Token,
+		l2Token,
+		amount,
+		to,
+	});
+
+	return writeContract(client, {
+		account: account!,
+		abi: l1StandardBridge,
+		address: l1StandardBridgeAddress,
+		chain,
+		functionName,
+		args,
+		maxFeePerGas,
+		maxPriorityFeePerGas,
+		nonce,
+		gas,
+	} satisfies WriteContractParameters as any);
+}

package/src/mantle/actions/depositETH.ts

@@ -0,0 +1,102 @@
+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 { l1StandardBridge } 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 { DepositETHRequest } from "../types/deposit.js";
+import { parseDepositRequest } from "../utils/parseDepositRequest.js";
+
+export type DepositETHParameters<
+	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, "l1StandardBridge"> & {
+		/** L2 transaction request. */
+		request: DepositETHRequest;
+		/**
+		 * Gas limit for transaction execution on the L1.
+		 */
+		gas?: bigint | undefined;
+	};
+export type DepositETHReturnType = Hash;
+export type DepositETHErrorType = WriteContractErrorType | ErrorType;
+
+/**
+ * @param client - Client to use
+ * @param parameters - {@link DepositERC20Parameters}
+ * @returns The L1 transaction hash. {@link DepositERC20ReturnType}
+ */
+export async function depositETH<
+	chain extends Chain | undefined,
+	account extends Account | undefined,
+	chainOverride extends Chain | undefined = undefined,
+>(
+	client: Client<Transport, chain, account>,
+	parameters: DepositETHParameters<chain, account, chainOverride>,
+) {
+	const {
+		account,
+		chain = client.chain,
+		gas,
+		maxFeePerGas,
+		maxPriorityFeePerGas,
+		nonce,
+		request: { amount, to },
+		targetChain,
+	} = parameters;
+
+	const l1StandardBridgeAddress = (() => {
+		if (parameters.l1StandardBridgeAddress) {
+			return parameters.l1StandardBridgeAddress;
+		}
+		if (chain) return targetChain!.contracts.l1StandardBridge[chain.id].address;
+		return Object.values(targetChain!.contracts.l1StandardBridge)[0].address;
+	})();
+
+	const { functionName, args } = parseDepositRequest({
+		type: "eth",
+		amount,
+		to,
+	});
+
+	return writeContract(client, {
+		account: account!,
+		abi: l1StandardBridge,
+		address: l1StandardBridgeAddress,
+		chain,
+		functionName,
+		args,
+		maxFeePerGas,
+		maxPriorityFeePerGas,
+		nonce,
+		gas,
+		value: amount,
+	} satisfies WriteContractParameters as any);
+}

package/src/mantle/actions/depositMNT.ts

@@ -0,0 +1,101 @@
+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 { l1StandardBridge } 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 { DepositMNTRequest } from "../types/deposit.js";
+import { parseDepositRequest } from "../utils/parseDepositRequest.js";
+
+export type DepositMNTParameters<
+	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, "l1StandardBridge"> & {
+		/** L2 transaction request. */
+		request: DepositMNTRequest;
+		/**
+		 * Gas limit for transaction execution on the L1.
+		 */
+		gas?: bigint | undefined;
+	};
+export type DepositMNTReturnType = Hash;
+export type DepositMNTErrorType = WriteContractErrorType | ErrorType;
+
+/**
+ * @param client - Client to use
+ * @param parameters - {@link DepositMNTParameters}
+ * @returns The L1 transaction hash. {@link DepositMNTReturnType}
+ */
+export async function depositMNT<
+	chain extends Chain | undefined,
+	account extends Account | undefined,
+	chainOverride extends Chain | undefined = undefined,
+>(
+	client: Client<Transport, chain, account>,
+	parameters: DepositMNTParameters<chain, account, chainOverride>,
+) {
+	const {
+		account,
+		chain = client.chain,
+		gas,
+		maxFeePerGas,
+		maxPriorityFeePerGas,
+		nonce,
+		request: { amount, to },
+		targetChain,
+	} = parameters;
+
+	const l1StandardBridgeAddress = (() => {
+		if (parameters.l1StandardBridgeAddress) {
+			return parameters.l1StandardBridgeAddress;
+		}
+		if (chain) return targetChain!.contracts.l1StandardBridge[chain.id].address;
+		return Object.values(targetChain!.contracts.l1StandardBridge)[0].address;
+	})();
+
+	const { functionName, args } = parseDepositRequest({
+		type: "mnt",
+		amount,
+		to,
+	});
+
+	return writeContract(client, {
+		account: account!,
+		abi: l1StandardBridge,
+		address: l1StandardBridgeAddress,
+		chain,
+		functionName,
+		args,
+		maxFeePerGas,
+		maxPriorityFeePerGas,
+		nonce,
+		gas,
+	} satisfies WriteContractParameters as any);
+}

package/src/mantle/actions/estimateDepositERC20Gas.ts

@@ -0,0 +1,113 @@
+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 { UnionEvaluate, UnionOmit } from "viem";
+import {
+	estimateContractGas,
+	type EstimateContractGasErrorType,
+	type EstimateContractGasParameters,
+} from "viem/actions";
+import type { FormattedTransactionRequest } from "viem/utils";
+import { l1StandardBridge } 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 { DepositERC20Request } from "../types/deposit.js";
+import { parseDepositRequest } from "../utils/parseDepositRequest.js";
+
+export type EstimateDepositERC20GasParameters<
+	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, "l1StandardBridge"> & {
+		/** L2 transaction request. */
+		request: DepositERC20Request;
+		/** Gas limit for transaction execution on the L1. */
+		gas?: bigint | undefined;
+	};
+
+export type EstimateDepositERC20GasReturnType = bigint;
+
+export type EstimateDepositERC20GasErrorType =
+	| EstimateContractGasErrorType
+	| ErrorType;
+
+/**
+ * @param client - Client to use
+ * @param parameters - {@link EstimateDepositERC20GasParameters}
+ * @returns The L1 transaction hash. {@link EstimateDepositERC20GasReturnType}
+ */
+export async function estimateDepositERC20Gas<
+	chain extends Chain | undefined,
+	account extends Account | undefined,
+	chainOverride extends Chain | undefined = undefined,
+>(
+	client: Client<Transport, chain, account>,
+	parameters: EstimateDepositERC20GasParameters<chain, account, chainOverride>,
+) {
+	const {
+		account,
+		chain = client.chain,
+		gas,
+		maxFeePerGas,
+		maxPriorityFeePerGas,
+		nonce,
+		request: { l1Token, l2Token, amount, to },
+		targetChain,
+	} = parameters;
+
+	const l1StandardBridgeAddress = (() => {
+		if (parameters.l1StandardBridgeAddress) {
+			return parameters.l1StandardBridgeAddress;
+		}
+		if (chain) return targetChain!.contracts.l1StandardBridge[chain.id].address;
+		return Object.values(targetChain!.contracts.l1StandardBridge)[0].address;
+	})();
+
+	const { functionName, args } = parseDepositRequest({
+		type: "erc20",
+		l1Token,
+		l2Token,
+		amount,
+		to,
+	});
+
+	const params = {
+		account,
+		abi: l1StandardBridge,
+		address: l1StandardBridgeAddress,
+		functionName,
+		args,
+		gas,
+		maxFeePerGas,
+		maxPriorityFeePerGas,
+		nonce,
+		// TODO: Not sure `chain` is necessary since it's not used downstream
+		// in `estimateContractGas` or `estimateGas`
+		// @ts-ignore
+		chain,
+	} satisfies EstimateContractGasParameters<
+		typeof l1StandardBridge,
+		typeof functionName
+	>;
+	return estimateContractGas(client, params as any);
+}

package/src/mantle/actions/estimateDepositETHGas.ts

@@ -0,0 +1,113 @@
+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 { UnionEvaluate, UnionOmit } from "viem";
+import {
+	estimateContractGas,
+	type EstimateContractGasErrorType,
+	type EstimateContractGasParameters,
+} from "viem/actions";
+import type { FormattedTransactionRequest } from "viem/utils";
+import { l1StandardBridge } 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 { DepositETHRequest } from "../types/deposit.js";
+import { parseDepositRequest } from "../utils/parseDepositRequest.js";
+
+export type EstimateDepositETHGasParameters<
+	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, "l1StandardBridge"> & {
+		/** L2 transaction request. */
+		request: DepositETHRequest;
+		/** Gas limit for transaction execution on the L1. */
+		gas?: bigint | undefined;
+	};
+
+export type EstimateDepositETHGasReturnType = bigint;
+
+export type EstimateDepositETHGasErrorType =
+	| EstimateContractGasErrorType
+	| ErrorType;
+
+/**
+ * @param client - Client to use
+ * @param parameters - {@link EstimateDepositETHGasParameters}
+ * @returns The L1 transaction hash. {@link EstimateDepositETHGasReturnType}
+ */
+export async function estimateDepositETHGas<
+	chain extends Chain | undefined,
+	account extends Account | undefined,
+	chainOverride extends Chain | undefined = undefined,
+>(
+	client: Client<Transport, chain, account>,
+	parameters: EstimateDepositETHGasParameters<chain, account, chainOverride>,
+) {
+	const {
+		account,
+		chain = client.chain,
+		gas,
+		maxFeePerGas,
+		maxPriorityFeePerGas,
+		nonce,
+		request: { amount, to },
+		targetChain,
+	} = parameters;
+
+	const l1StandardBridgeAddress = (() => {
+		if (parameters.l1StandardBridgeAddress) {
+			return parameters.l1StandardBridgeAddress;
+		}
+		if (chain) return targetChain!.contracts.l1StandardBridge[chain.id].address;
+		return Object.values(targetChain!.contracts.l1StandardBridge)[0].address;
+	})();
+
+	const { functionName, args } = parseDepositRequest({
+		type: "eth",
+		amount,
+		to,
+	});
+
+	const params = {
+		account,
+		abi: l1StandardBridge,
+		address: l1StandardBridgeAddress,
+		functionName,
+		args,
+		gas,
+		maxFeePerGas,
+		maxPriorityFeePerGas,
+		nonce,
+		// TODO: Not sure `chain` is necessary since it's not used downstream
+		// in `estimateContractGas` or `estimateGas`
+		// @ts-ignore
+		chain,
+		// @ts-ignore
+		value: amount,
+	} satisfies EstimateContractGasParameters<
+		typeof l1StandardBridge,
+		typeof functionName
+	>;
+	return estimateContractGas(client, params as any);
+}