@berachain/berajs 0.1.0 → 0.1.2

package/src/actions/transactions/beraWriteContract.ts

@@ -0,0 +1,722 @@
+import {
+  getPublicClient,
+  getWalletClient,
+  type SwitchChainErrorType,
+  switchChain,
+} from "@wagmi/core";
+import {
+  type Abi,
+  BaseError,
+  type ContractFunctionArgs,
+  type ContractFunctionName,
+  createWalletClient,
+  decodeErrorResult,
+  type GetTransactionCountReturnType,
+  type Hex,
+  HttpRequestError,
+  http,
+  type TransactionReceipt,
+  type WalletCallReceipt,
+} from "viem";
+
+import { ChainId, defaultChainId } from "@berachain/config/internal";
+
+import { commonAbiErrors } from "~/abi/utils/commonAbiErrors";
+import { assertPublicClient } from "~/errors/assert";
+import { BeraError } from "~/errors/BeraError";
+import { getRevertReason } from "~/errors/getRevertReason";
+import { InvalidArgumentError } from "~/errors/InvalidArgumentError";
+import { parseDecodedError, parseViemError } from "~/errors/parseViemError";
+import { RequestError } from "~/errors/RequestError";
+import { TransactionFailedError } from "~/errors/TransactionFailedError";
+import type { IContractWrite } from "~/types";
+import { DEFAULT_METAMASK_GAS_LIMIT } from "~/utils/constants";
+import { getTestClient } from "~/utils/getTestClient";
+import { seconds } from "~/utils/time";
+
+/**
+ * Setting 1 seconds as refresh interval since block time is 2 seconds.
+ *
+ * Keeping this longer will increase the time to wait for the transaction to be confirmed.
+ * If tx is confirmed after 0.5 seconds, the user would have to wait for 1.5 seconds more before UI is updated.
+ * 1 seconds seems a good compromise. A shorter interval
+ */
+const defaultPollingInterval = seconds(1);
+
+const increaseByPercentage = (value: bigint, percentage: number) => {
+  return (value * (100n + BigInt(percentage))) / 100n;
+};
+
+/**
+ * This helps prevent IntegerOutOfRangeError by not providing a nonce if it's too large.
+ *
+ * Despite this should not be possible, some users have experienced this error. We're collecting
+ * the error and the nonce value to help debug the issue.
+ */
+function parseNonce({
+  nonceResult,
+  onWarning,
+}: {
+  nonceResult: PromiseSettledResult<GetTransactionCountReturnType | undefined>;
+  onWarning?: (e: BeraError) => void;
+}): number | undefined {
+  if (nonceResult.status === "fulfilled") {
+    if (nonceResult.value && nonceResult.value > Number.MAX_SAFE_INTEGER) {
+      // This happened only to one user that manually set a very high nonce.
+      // This is very unlikely to happen if we get the nonce from the latest block instead of pending.
+      onWarning?.(
+        new BeraError({
+          message:
+            "Nonce is too large. No nonce will be provided to avoid IntegerOutOfRangeError.",
+          cause: nonceResult.value,
+          level: "debug",
+        }),
+      );
+      return undefined;
+    }
+
+    return nonceResult.value;
+  }
+  return undefined;
+}
+
+export function isImpersonateAccount(chainId: number = defaultChainId) {
+  return chainId === ChainId.BEPOLIA
+    ? process.env.NEXT_PUBLIC_80069_ANVIL_IMPERSONATE_ACCOUNT === "true"
+    : process.env.NEXT_PUBLIC_80094_ANVIL_IMPERSONATE_ACCOUNT === "true";
+}
+
+export async function beraWriteContract<
+  abi extends Abi | undefined = undefined,
+  functionName extends abi extends Abi
+    ? ContractFunctionName<abi>
+    : never = abi extends Abi ? ContractFunctionName<abi> : never,
+  params extends abi extends Abi
+    ? ContractFunctionArgs<abi, "payable" | "nonpayable", functionName>
+    : never = abi extends Abi
+    ? ContractFunctionArgs<abi, "payable" | "nonpayable", functionName>
+    : never,
+>(
+  args: IContractWrite<abi, functionName, params> & {
+    enableSimulateCalls?: boolean;
+    chainId?: number;
+    impersonateAccount?: boolean;
+    /**
+     * The polling interval in milliseconds to fetch the on-chain transaction status
+     * @default 1000 (1 second)
+     */
+    pollingInterval?: number;
+    /**
+     * The timeout in milliseconds to wait for the transaction to be confirmed.
+     * @default 120_000 (2 minutes)
+     */
+    txConfirmationTimeout?: number;
+  },
+): Promise<
+  | TransactionReceipt
+  | WalletCallReceipt<bigint, "success" | "reverted">
+  | undefined
+> {
+  if (
+    process.env.NODE_ENV === "development" &&
+    !args.contractName &&
+    // let's avoid this for eip5972 calls
+    args.address &&
+    !("calls" in args || args.calls)
+  ) {
+    console.warn(
+      "beraWriteContract: Contract name is required. Either update the contract mapping in devrel or provide a contract name in ContractName enum",
+      "This is a development error and will be thrown in development mode only.",
+    );
+
+    throw new InvalidArgumentError({
+      property: "contractName",
+      value: args.contractName,
+      expected: "ContractName",
+      displayMessage: `[DEV] Contract name is required as it's not mapped in the devrel's contract mapping ${args.address}`,
+      level: "error",
+    });
+  }
+
+  const {
+    address,
+    calls,
+    value,
+    gasLimit,
+    onLoading,
+    onSuccess,
+    onWarning,
+    onError,
+    onSubmission,
+    wagmiConfig,
+    walletClient: _walletClient,
+    account: argsAccount,
+    txConfirmationTimeout = 120_000,
+    chainId = defaultChainId,
+    impersonateAccount = isImpersonateAccount(chainId),
+    errorsAbi: _errorsAbi = [],
+    pollingInterval = defaultPollingInterval,
+    ...rest
+  } = args;
+
+  onLoading?.(args);
+
+  const data = "data" in rest ? (rest.data as Hex) : undefined;
+
+  const globalAbi = [
+    ...commonAbiErrors,
+    ..._errorsAbi,
+    ...("abi" in rest && rest.abi && Array.isArray(rest.abi)
+      ? (rest.abi as unknown as Abi)
+      : []),
+  ] as unknown as abi extends undefined ? Abi : abi;
+
+  let walletClient = _walletClient;
+
+  if (!wagmiConfig) {
+    onError?.(
+      new InvalidArgumentError({
+        property: "wagmiConfig",
+        value: wagmiConfig,
+        expected: "Config",
+      }),
+      args,
+    );
+    return;
+  }
+
+  const isLocalAccount = walletClient?.account?.type === "local";
+
+  if (!isLocalAccount) {
+    try {
+      /**
+       * This is needed because if we don't wrap the button into an ActionButton, or the connector doesn't warn us that the chain
+       * is not synced with the dapp, we'll get a ChainMismatchError.
+       */
+      await switchChain(wagmiConfig, { chainId });
+    } catch (e) {
+      const error = e as SwitchChainErrorType;
+      onError?.(
+        new BeraError({
+          cause: error,
+          displayMessage: "There was an error switching to the chain.",
+        }),
+        args,
+      );
+      return;
+    }
+  }
+
+  if (!walletClient) {
+    try {
+      walletClient = await getWalletClient(wagmiConfig, { chainId });
+    } catch (e) {
+      onError?.(
+        new BeraError({
+          cause: e,
+          displayMessage: "There was an error connecting to the wallet.",
+        }),
+        args,
+      );
+      return;
+    }
+  }
+
+  if (!walletClient) {
+    onError?.(
+      new InvalidArgumentError({
+        displayMessage: "There was an error connecting to the wallet.",
+        property: "walletClient",
+        value: walletClient,
+        expected: "WalletClient",
+      }),
+      args,
+    );
+    return;
+  }
+
+  const account = argsAccount || walletClient.account;
+
+  if (!account) {
+    onError?.(
+      new InvalidArgumentError({
+        property: "account",
+        value: account,
+        expected: "Account",
+      }),
+      args,
+    );
+    return;
+  }
+
+  const accountAddress =
+    typeof account === "string" ? account : account.address;
+
+  const publicClient = getPublicClient(wagmiConfig, {
+    chainId,
+  });
+
+  try {
+    assertPublicClient(publicClient);
+  } catch (error) {
+    onError?.(error as InvalidArgumentError, args);
+    return;
+  }
+
+  if (impersonateAccount) {
+    const testClient = getTestClient(chainId);
+    await testClient.impersonateAccount({
+      address: accountAddress,
+    });
+
+    walletClient = createWalletClient({
+      transport: http(testClient.transport.url),
+      account,
+      chain: walletClient.chain,
+    });
+  }
+  /**
+   * If tx is submitted, this will be assigned the tx hash
+   */
+  let txHash: Hex | undefined;
+  /**
+   * This is just needed for the error object
+   */
+  const input = {
+    calls: "calls" in rest ? rest.calls : undefined,
+    params: "params" in rest ? rest.params : undefined,
+    value,
+    data: "data" in rest ? (rest.data as Hex) : undefined,
+  } as const;
+
+  try {
+    /**
+     * Nonces are security-critical for preventing replay attacks.
+     */
+    const noncePromise = publicClient
+      .getTransactionCount({
+        address: accountAddress,
+        /**
+         * We won't use pending any more because if someone previously send a txn with a higher nonce, this won't be executed
+         * unless all the previous nonces are executed.
+         *
+         * This will lead to a UX issue where the user thinks the txn was not sent because it's pending forever.
+         *
+         * The only case where pending is needed is if chain is halted or the user is sending multiple transactions at the same time.
+         * However, it's less likely to happen.
+         *
+         * A lot of waitForTransactionReceipt were timing out, and maybe it was related to that.
+         */
+        blockTag: "latest",
+      })
+      // This must be caught to prevent the promise from rejecting before being awaited
+      .catch(() => undefined);
+
+    /**
+     * These are properties that are shared between the simulation and gas estimation whether we have
+     */
+    const sharedTxProperties = {
+      account: accountAddress,
+      to: address,
+      address,
+      chainId,
+      value,
+    } as const;
+
+    if (calls) {
+      const parsedCalls = calls.map((call) => {
+        if ("abi" in call && Array.isArray(globalAbi)) {
+          globalAbi.push(...(call.abi as Abi));
+        }
+
+        if ("data" in call) {
+          return {
+            to: call.address,
+            data: call.data as Hex,
+            value: call.value ?? 0n,
+          };
+        }
+        if ("abi" in call && "functionName" in call) {
+          const params = "params" in call ? call.params : undefined;
+
+          return {
+            to: call.address,
+            abi: call.abi as Abi,
+            functionName: call.functionName as ContractFunctionName<Abi>,
+            args: params as readonly unknown[],
+            value: call.value ?? 0n,
+          };
+        }
+        return {
+          to: call.address,
+          value: call.value ?? 0n,
+        };
+      });
+
+      if (args.enableSimulateCalls) {
+        const res = await publicClient.simulateCalls({
+          calls: parsedCalls,
+          account,
+        });
+
+        const failedCallIndex = res.results.findIndex(
+          (result) => result.status === "failure",
+        );
+        if (failedCallIndex !== -1) {
+          if (res.block.number === null) {
+            throw new InvalidArgumentError({
+              property: "blockNumber",
+              value: res.block.number,
+              expected: "bigint",
+              message: "Block number is null",
+            });
+          }
+
+          const failedCall = res.results[failedCallIndex];
+
+          const { reason: decodedReason } =
+            failedCall.data && failedCall.data !== "0x"
+              ? {
+                  reason: parseDecodedError(
+                    decodeErrorResult({
+                      data: failedCall.data,
+                      abi: globalAbi,
+                    }),
+                  ),
+                }
+              : parseViemError({
+                  error: failedCall.error as Error,
+                  revertIfUnknown: false,
+                  abi: globalAbi,
+                });
+
+          onError?.(
+            new TransactionFailedError({
+              cause: failedCall.error,
+              txHash,
+              chainId,
+              reason: decodedReason,
+              abi: globalAbi,
+              input,
+              blockNumber: res.block.number,
+            }),
+            args,
+          );
+          return;
+        }
+      }
+
+      if (process.env.NODE_ENV === "test") {
+        // sendCalls uses EIP-5972 so that the wallet provider can send batch calls with EIP-7702
+        // @todo We can simulate it using the EIP-7702StatelessDelegator ABI, assuming the wallet has sent authorized metamask's contract
+        throw new InvalidArgumentError({
+          displayMessage: "Batch calls are not supported in test environment",
+          expected: "not test",
+          property: "NODE_ENV",
+          value: process.env.NODE_ENV,
+          level: "fatal",
+        });
+      }
+
+      const request = await walletClient.sendCalls({
+        calls: parsedCalls,
+        account,
+        // This is needed to ensure that the transaction is atomic
+        // If this was not set, we might have a list of receipts instead of a single one
+        forceAtomic: true,
+      });
+
+      /**
+       * This is different from the other onSubmission callbacks
+       * however `request` does not have the txHash, but just the request id to the wallet provider
+       * Wallet provider should support the showCallStatus method. MM does not atm.
+       */
+      onSubmission?.({ id: request.id }, args);
+
+      // If we get the call status right after the call is submitted, it will be pending
+      // Receipts will be empty
+      // Here's an example of the response:
+      //  {
+      //     "id": "0x939c0c8b9fd546878b042c8232802450",
+      //     "status": "pending",
+      //     "atomic": true,
+      //     "chainId": 80069,
+      //     "receipts": [],
+      //     "statusCode": 100,
+      //     "version": "2.0.0"
+      // }
+      // const callStatusPending = await walletClient.getCallsStatus({
+      //   id: request.id,
+      // });
+
+      // This will wait for the transaction to be submitted to the chain
+      const callStatus = await walletClient.waitForCallsStatus({
+        id: request.id,
+        pollingInterval,
+        timeout: txConfirmationTimeout,
+      });
+
+      if (callStatus.status === "success") {
+        const receipt = callStatus.receipts?.[0];
+
+        if (!receipt) {
+          // This should never happen
+          throw new BeraError({
+            message: "Call status is success but no receipt was found",
+            cause: callStatus,
+            level: "error",
+            reason: "CALL_STATUS_SUCCESS_BUT_NO_RECEIPT",
+          });
+        }
+
+        onSuccess?.(receipt, args);
+        return receipt;
+      }
+
+      console.error("wallet_sendCalls: Call failed", callStatus);
+
+      throw new TransactionFailedError({
+        cause: callStatus,
+        level: "error",
+        input,
+        txHash,
+        abi: globalAbi,
+        chainId,
+      });
+    }
+
+    if (data) {
+      // In this scenario data was already encoded by external library
+      // and we can use it directly. If ABI was provided, errors will be decoded by parseViemError
+      // This might also be just a value transaction
+
+      // Add gas estimation for direct transactions
+      const [simulationResult, estimatedGas, nonceResult] =
+        await Promise.allSettled([
+          publicClient.call({
+            ...sharedTxProperties,
+            data,
+          }),
+          gasLimit ??
+            publicClient.estimateGas({
+              ...sharedTxProperties,
+              data,
+            }),
+          noncePromise,
+        ]);
+
+      if (simulationResult.status === "rejected") {
+        throw simulationResult.reason;
+      }
+
+      const gas =
+        estimatedGas.status === "fulfilled"
+          ? increaseByPercentage(estimatedGas.value, 10)
+          : DEFAULT_METAMASK_GAS_LIMIT;
+
+      txHash = await walletClient.sendTransaction({
+        data,
+        to: address,
+        account,
+        gas,
+        chainId,
+        nonce: parseNonce({
+          nonceResult,
+          onWarning(e) {
+            onWarning?.(e, args);
+          },
+        }),
+        value,
+      });
+      onSubmission?.({ txHash }, args);
+    } else if ("abi" in rest && "functionName" in rest) {
+      const { abi, functionName } = rest as {
+        abi: NonNullable<abi>;
+        functionName: NonNullable<functionName>;
+      };
+
+      const params = "params" in rest ? rest.params : undefined;
+      // Run simulation and gas estimation in parallel
+      // TODO: figure out clean way to early detect errors and effectively show them on the UI
+      const [simulationResult, gasEstimateResult, nonceResult] =
+        await Promise.allSettled([
+          // @ts-expect-error nested type issues. Be careful when changing this.
+          publicClient.simulateContract({
+            ...sharedTxProperties,
+            abi: globalAbi as typeof abi,
+            functionName,
+            args: params,
+            account,
+          }),
+          // Only estimate gas if no gasLimit is provided
+          gasLimit ??
+            // @ts-expect-error nested type issues. Be careful when changing this.
+            publicClient.estimateContractGas({
+              ...sharedTxProperties,
+              abi: globalAbi,
+              functionName,
+              args: params,
+            }),
+          noncePromise,
+        ]);
+
+      if (simulationResult.status === "rejected") {
+        throw simulationResult.reason;
+      }
+
+      const estimatedGas =
+        gasLimit ??
+        (gasEstimateResult.status === "fulfilled"
+          ? increaseByPercentage(gasEstimateResult.value, 10)
+          : DEFAULT_METAMASK_GAS_LIMIT);
+
+      // @ts-expect-error nested type issues. Be careful when changing this.
+      txHash = await walletClient.writeContract({
+        ...simulationResult.value.request,
+        chainId,
+        gas: estimatedGas,
+        nonce: parseNonce({
+          nonceResult,
+          onWarning(e) {
+            onWarning?.(e, args);
+          },
+        }),
+      });
+      onSubmission?.({ txHash }, args);
+    } else {
+      const [nonceResult] = await Promise.allSettled([noncePromise]);
+      txHash = await walletClient.sendTransaction({
+        chainId,
+        to: address,
+        value,
+        account,
+        nonce: parseNonce({
+          nonceResult,
+          onWarning(e) {
+            onWarning?.(e, args);
+          },
+        }),
+      });
+      onSubmission?.({ txHash }, args);
+    }
+
+    if (process.env.NODE_ENV === "test") {
+      const testClient = getTestClient(chainId);
+      await testClient.mine({ blocks: 1 });
+    }
+
+    const confirmationReceipt = await publicClient.waitForTransactionReceipt({
+      hash: txHash,
+      pollingInterval,
+      timeout: txConfirmationTimeout,
+      confirmations: 1,
+    });
+
+    if (confirmationReceipt.status === "success") {
+      onSuccess?.(confirmationReceipt, args);
+    } else {
+      const revertReason = await getRevertReason({
+        publicClient,
+        blockNumber: confirmationReceipt.blockNumber,
+        to: address,
+        account: accountAddress,
+        abi: globalAbi,
+        args:
+          "params" in rest ? (rest.params as readonly unknown[]) : undefined,
+        functionName:
+          "functionName" in rest
+            ? (rest.functionName as functionName)
+            : undefined,
+        value,
+        data,
+      });
+
+      if (process.env.NODE_ENV === "test") {
+        console.error("beraWriteContract: Revert reason", revertReason);
+      }
+
+      onError?.(
+        new TransactionFailedError({
+          reason: revertReason.reason,
+          txHash,
+          receipt: confirmationReceipt,
+          to: address,
+          functionName:
+            "functionName" in rest
+              ? (rest.functionName as functionName)
+              : undefined,
+          input,
+          chainId,
+          abi: globalAbi,
+          blockNumber: confirmationReceipt.blockNumber,
+        }),
+        args,
+      );
+    }
+    return confirmationReceipt;
+  } catch (e) {
+    if (e instanceof BeraError) {
+      onError?.(e, args);
+    } else if (e instanceof Error) {
+      const viemError = parseViemError({
+        error: e,
+        revertIfUnknown: false,
+        abi: globalAbi,
+      });
+
+      if (
+        viemError &&
+        viemError.rootCause instanceof BaseError &&
+        "url" in viemError.rootCause
+      ) {
+        onError?.(
+          new RequestError({
+            cause: viemError.rootCause,
+            response: undefined,
+            endpoint: {
+              url: viemError.rootCause.url as string,
+              type: "rpc",
+            },
+            statusCode:
+              viemError.rootCause instanceof HttpRequestError
+                ? viemError.rootCause.status
+                : undefined,
+          }),
+          args,
+        );
+        return;
+      }
+      onError?.(
+        new TransactionFailedError({
+          cause: e,
+          to: address,
+          txHash,
+          chainId,
+          abi: globalAbi,
+          functionName:
+            "functionName" in rest
+              ? (rest.functionName as functionName)
+              : undefined,
+          input,
+        }),
+        args,
+      );
+    } else {
+      onError?.(
+        new TransactionFailedError({
+          cause: e,
+          txHash,
+          to: address,
+          chainId,
+          functionName:
+            "functionName" in rest
+              ? (rest.functionName as functionName)
+              : undefined,
+          input,
+          abi: globalAbi,
+        }),
+        args,
+      );
+    }
+  }
+}