@berachain/berajs 0.1.1 → 0.2.0

package/src/actions/governance/getDecodedFunctionData.ts

@@ -0,0 +1,167 @@
+import {
+  type Abi,
+  type AbiFunction,
+  type AbiItem,
+  type Address,
+  decodeFunctionData,
+  erc20Abi,
+  type PublicClient,
+  pad,
+  toFunctionSignature,
+  trim,
+} from "viem";
+
+import { appConfig, defaultChainId } from "@berachain/config/internal";
+
+import { beraChefAbi } from "~/abi/pol/beraChef";
+import { rewardVaultAbi } from "~/abi/pol/rewardVault";
+
+// Function to check if ABI contains proxy-related functions
+function isProxyABI(abi: Abi[]): boolean {
+  return abi.some(
+    (item: any) =>
+      item.name === "implementation" ||
+      item.name === "proxyType" ||
+      (item.type === "constructor" &&
+        item.inputs?.[0]?.name === "implementation"),
+  );
+}
+
+/**
+ * {@link https://docs.berascan.com/api-endpoints/contracts}
+ */
+async function _getAbi({
+  contractAddress,
+  chainId,
+  publicClient,
+}: {
+  contractAddress: Address;
+  chainId: number;
+  publicClient: PublicClient;
+}) {
+  const url = `https://api.etherscan.io/v2/api?module=contract&action=getabi&address=${contractAddress}&apikey=${appConfig.apiKeys.private.etherscan}&chainId=${chainId}`;
+
+  const response = await fetch(url);
+
+  if (!response.ok) {
+    throw new Error(`Failed to fetch ABI: ${response.statusText}`);
+  }
+
+  const data = await response.json();
+  if (data.status === "0") throw new Error(data.result);
+
+  const abi = JSON.parse(data.result);
+  if (!isProxyABI(abi)) return abi;
+
+  const implementationResult = await publicClient.getStorageAt({
+    address: contractAddress,
+    // bytes32(uint256(keccak256('eip1967.proxy.implementation')) - 1)).
+    slot: "0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc",
+  });
+
+  // if implementation is not set, it might be a beacon proxy
+  if (!implementationResult || trim(implementationResult) === "0x00")
+    return abi;
+  // storage slot has 32 byes (64 characters) but an address only has 20 bytes (40 characters)
+  const implementationAddress = pad(trim(implementationResult), { size: 20 });
+  return _getAbi({
+    contractAddress: implementationAddress as `0x${string}`,
+    chainId,
+    publicClient,
+  });
+}
+
+async function _getAbiForCallData({
+  address,
+  callData,
+  knownAbi,
+  chainId,
+  publicClient,
+}: {
+  address: Address;
+  callData: `0x${string}`;
+  knownAbi: AbiItem[];
+  chainId: number;
+  publicClient: PublicClient;
+}) {
+  try {
+    if (decodeFunctionData({ data: callData, abi: knownAbi })) {
+      return knownAbi;
+    }
+  } catch {}
+  try {
+    return await _getAbi({ contractAddress: address, chainId, publicClient });
+  } catch {}
+}
+
+function _decodeCallData(callData: `0x${string}`, abi: AbiItem[]) {
+  try {
+    return decodeFunctionData({ data: callData, abi });
+  } catch {
+    return undefined;
+  }
+}
+
+function _findAbiItem(abi: AbiItem[], functionName: string) {
+  return abi.find(
+    (a: AbiItem) => a.type === "function" && a.name === functionName,
+  ) as AbiFunction | undefined;
+}
+
+function _getFunctionSignature(abiItem: AbiFunction | undefined) {
+  if (!abiItem) return;
+  try {
+    return toFunctionSignature(abiItem);
+  } catch (error) {
+    console.error(error);
+  }
+}
+
+/**
+ * Decodes the function data from a given contract address and calldata.
+ *
+ * This function attempts to decode the provided calldata using a known set of ABIs.
+ * If the call data cannot be decoded with the known ABIs, it fetches the ABI from the blockexplorer API.
+ *
+ * @param address - The contract address.
+ * @param callData - The calldata to decode, in hexadecimal format.
+ * @returns An object containing the decoded ABI item, function signature, function name, and arguments.
+ */
+export async function getDecodedFunctionData({
+  address,
+  callData,
+  chainId = defaultChainId,
+  publicClient,
+}: {
+  address: Address;
+  callData: `0x${string}`;
+  chainId?: number;
+  publicClient: PublicClient;
+}) {
+  const knownAbi = [...beraChefAbi, ...rewardVaultAbi, ...erc20Abi];
+
+  const abi = await _getAbiForCallData({
+    address,
+    callData,
+    knownAbi,
+    chainId,
+    publicClient,
+  });
+
+  const decodedData = _decodeCallData(callData, abi);
+
+  if (!abi || !decodedData) {
+    return { args: [] };
+  }
+
+  const abiItem = _findAbiItem(abi, decodedData.functionName);
+
+  const functionSignature = _getFunctionSignature(abiItem);
+
+  return {
+    abiItem,
+    functionSignature,
+    functionName: decodedData.functionName,
+    args: decodedData.args as unknown[],
+  };
+}

package/src/actions/governance/getProposalDetails.ts

@@ -0,0 +1,40 @@
+import type { PublicClient } from "viem";
+
+import {
+  GetProposal,
+  type GetProposalQuery,
+  type GetProposalQueryVariables,
+  type ProposalWithVotesFragment,
+} from "@berachain/graphql/governance";
+
+import { getApolloClient } from "~/actions/clients/getApolloClient";
+import { computeActualStatus } from "./computeActualStatus";
+
+export async function getProposalDetails({
+  proposalId,
+  ...args
+}: BeraJS.BaseFunctionArgs & {
+  proposalId: string;
+  client?: PublicClient;
+}): Promise<ProposalWithVotesFragment | undefined> {
+  const governanceClient = getApolloClient("governance.subgraph", args);
+
+  const res = await governanceClient.query<
+    GetProposalQuery,
+    GetProposalQueryVariables
+  >({
+    query: GetProposal,
+    variables: {
+      id: proposalId,
+    },
+  });
+
+  if (!res.data.proposal) {
+    return undefined;
+  }
+
+  return {
+    ...res.data.proposal,
+    status: computeActualStatus(res.data.proposal),
+  } as ProposalWithVotesFragment;
+}

package/src/actions/governance/getProposalFromTx.ts

@@ -0,0 +1,100 @@
+import {
+  type Address,
+  type PublicClient,
+  parseEventLogs,
+  type TransactionReceipt,
+} from "viem";
+
+import {
+  type ExecutableCallSubsetFragment,
+  ProposalStatus,
+  type ProposalWithVotesFragment,
+} from "@berachain/graphql/governance";
+
+import { governanceAbi } from "~/abi/governance/governance";
+import { assertPublicClient } from "~/errors/assert";
+import { parseProposalBody } from "./parseProposalBody";
+
+export async function getProposalFromTx(
+  args: {
+    publicClient: PublicClient | undefined;
+  } & (
+    | {
+        tx: TransactionReceipt;
+      }
+    | {
+        txHash: Address;
+      }
+  ),
+): Promise<ProposalWithVotesFragment | null> {
+  assertPublicClient(args.publicClient);
+
+  let tx: TransactionReceipt;
+
+  if ("tx" in args) {
+    tx = args.tx;
+  } else {
+    tx = await args.publicClient.getTransactionReceipt({ hash: args.txHash });
+  }
+
+  const creationEvent = tx?.logs
+    ? parseEventLogs({
+        abi: governanceAbi,
+        logs: tx.logs,
+        eventName: "ProposalCreated",
+      })?.at(0)
+    : undefined;
+
+  if (!tx || !creationEvent) {
+    return null;
+  }
+
+  const block = await args.publicClient.getBlock({
+    blockNumber: tx.blockNumber,
+  });
+  const fm = parseProposalBody({
+    description: creationEvent?.args.description as string,
+  });
+
+  return {
+    id: String(creationEvent.args.proposalId),
+    proposalId: String(creationEvent?.args.proposalId),
+    createdAt: block.timestamp.toString(),
+    title: fm.data.title,
+    createdAtBlock: block.timestamp.toString(),
+    voteStartAt: String(creationEvent?.args.voteStart),
+    voteEndAt: String(creationEvent?.args.voteEnd),
+    proposer: creationEvent?.args.proposer,
+    description: fm.content,
+    unverifiedForumLink: fm.data.forumLink,
+    pollResult: {
+      for: "0",
+      forVotersCount: 0,
+      forPercentage: "0",
+      against: "0",
+      againstVotersCount: 0,
+      againstPercentage: "0",
+      abstain: "0",
+      abstainVotersCount: 0,
+      abstainPercentage: "0",
+      total: "0",
+      totalVotersCount: 0,
+      totalTowardsQuorum: "0",
+    },
+    status: ProposalStatus.Pending,
+    quorum: null,
+    topics: fm.data.topics,
+    votes: [],
+    executableCalls: creationEvent?.args.targets.map(
+      (target, index) =>
+        ({
+          __typename: "ExecutableCall",
+          id: `${tx.transactionHash}-${index}`,
+          target: target as Address,
+          value: String(creationEvent?.args.values[index]),
+          calldata: creationEvent?.args.calldatas[index],
+        }) satisfies ExecutableCallSubsetFragment,
+    ),
+    timelock: undefined,
+  } satisfies ProposalWithVotesFragment;
+}

package/src/actions/governance/getProposalParams.ts

@@ -0,0 +1,246 @@
+import matter from "gray-matter";
+import {
+  type Address,
+  encodeFunctionData,
+  erc20Abi,
+  parseAbiItem,
+  toHex,
+} from "viem";
+
+import { beraChefAbi } from "~/abi/pol/beraChef";
+import { rewardVaultAbi } from "~/abi/pol/rewardVault";
+import { ProposalErrorCodes, ProposalTypeEnum } from "~/enum/governance";
+import type {
+  CustomProposal,
+  CustomProposalActionErrors,
+  CustomProposalErrors,
+  GovernanceTopic,
+} from "~/types/governance";
+import { hasAnyTruthyValues } from "~/utils/hasAnyTruthyValues";
+import { checkProposalField } from "./checkProposalField";
+import { getBodyErrors } from "./getBodyErrors";
+
+export const getProposalParams = ({
+  proposal,
+  currentTopic,
+  onError,
+}: {
+  /**
+   * The proposal to get the parameters for
+   */
+  proposal: CustomProposal;
+  /**
+   * The current topic
+   */
+  currentTopic: GovernanceTopic;
+  /**
+   * Callback to handle errors
+   */
+  onError?: (e: CustomProposalErrors) => void;
+}) => {
+  const e: CustomProposalErrors = getBodyErrors(proposal, currentTopic);
+
+  const actions: Address[] = [];
+
+  e.actions = proposal.actions.map((action, idx) => {
+    const errors: CustomProposalActionErrors = {};
+    errors.target = checkProposalField({
+      fieldOrType: "address",
+      value: action.target,
+    });
+
+    if (action.type === ProposalTypeEnum.CUSTOM_PROPOSAL) {
+      if (action.input === "ABI") {
+        errors.ABI = checkProposalField({
+          fieldOrType: "abi",
+          value: action.ABI,
+        });
+        if (!action.functionSignature) {
+          errors.functionSignature = ProposalErrorCodes.REQUIRED;
+        } else {
+          try {
+            const parsedSignatureAbi = parseAbiItem(action.functionSignature);
+            if (parsedSignatureAbi.type !== "function") {
+              console.error(
+                "parsedSignatureAbi is not a function",
+                parsedSignatureAbi,
+              );
+
+              errors.functionSignature = ProposalErrorCodes.INVALID_ABI;
+            } else {
+              errors.args = parsedSignatureAbi.inputs.map((input, index) => {
+                try {
+                  if ("components" in input) {
+                    return checkProposalField({
+                      // @ts-expect-error this is not typed, will throw if not valid
+                      fieldOrType: input.type,
+                      value: action.args?.[index],
+                      components: input.components,
+                    });
+                  }
+
+                  return checkProposalField({
+                    // @ts-expect-error this is not typed, will throw if not valid
+                    fieldOrType: input.type,
+                    value: action.args?.[index],
+                  });
+                } catch {
+                  return null;
+                }
+              });
+
+              if (!errors.args.some((v) => v)) {
+                actions[idx] = encodeFunctionData({
+                  abi: [parsedSignatureAbi],
+                  args: action.args,
+                });
+              }
+            }
+          } catch {
+            errors.functionSignature = ProposalErrorCodes.INVALID_ABI;
+          }
+        }
+      } else if (action.input === "rawCalldata") {
+        errors.rawCalldata = checkProposalField({
+          fieldOrType: "hex",
+          value: action.rawCalldata,
+        });
+        actions[idx] = action.rawCalldata!;
+      } else if (action.input === "message") {
+        errors.message = checkProposalField({
+          fieldOrType: "string",
+          value: action.message,
+        });
+        actions[idx] = toHex(action.message!);
+      } else {
+        throw new Error("Invalid input type");
+      }
+    } else if (
+      action.type === ProposalTypeEnum.WHITELIST_REWARD_VAULT ||
+      action.type === ProposalTypeEnum.BLACKLIST_REWARD_VAULT
+    ) {
+      errors.vault = checkProposalField({
+        fieldOrType: "address",
+        value: action.vault,
+      });
+
+      if (!errors.vault) {
+        const whiteList =
+          action.type === ProposalTypeEnum.WHITELIST_REWARD_VAULT;
+
+        actions[idx] = encodeFunctionData({
+          abi: beraChefAbi,
+          functionName: "setVaultWhitelistedStatus",
+          args: [action.vault!, whiteList, ""],
+        });
+      }
+    } else if (
+      action.type === ProposalTypeEnum.WHITELIST_REWARD_VAULT_INCENTIVE
+    ) {
+      errors.token = checkProposalField({
+        fieldOrType: "address",
+        value: action.token,
+      });
+
+      errors.minIncentiveRate = checkProposalField({
+        fieldOrType: "uint256",
+        value: action.minIncentiveRate,
+      });
+
+      errors.managerAddress = checkProposalField({
+        fieldOrType: "address",
+        value: action.managerAddress,
+      });
+
+      if (!errors.token && !errors.minIncentiveRate && !errors.managerAddress) {
+        actions[idx] = encodeFunctionData({
+          abi: rewardVaultAbi,
+          functionName: "whitelistIncentiveToken",
+          args: [
+            action.token!,
+            BigInt(action.minIncentiveRate!),
+            action.managerAddress!,
+          ],
+        });
+      }
+    } else if (action.type === ProposalTypeEnum.ERC20_TRANSFER) {
+      errors.amount = checkProposalField({
+        fieldOrType: "uint256",
+        value: action.amount,
+      });
+      errors.to = checkProposalField({
+        fieldOrType: "address",
+        value: action.to,
+      });
+      if (!errors.amount && !errors.to) {
+        actions[idx] = encodeFunctionData({
+          abi: erc20Abi,
+          functionName: "transfer",
+          args: [action.to!, BigInt(action.amount!)],
+        });
+      }
+    }
+
+    const hasErrors = hasAnyTruthyValues(errors);
+
+    if (!hasErrors) {
+      return null;
+    }
+
+    return errors;
+  });
+
+  onError?.(e);
+
+  if (
+    Object.getOwnPropertyNames(e)
+      .map((name) => e[name as keyof typeof e])
+      .some((v) => {
+        if (Array.isArray(v)) {
+          return v.filter((v) => v).length > 0;
+        }
+
+        if (v === null) {
+          return false;
+        }
+
+        return !!v;
+      })
+  ) {
+    console.warn("Proposal has errors", e);
+    return;
+  }
+
+  if (actions.length === 0) {
+    throw new Error("No actions submitted in proposal");
+  }
+
+  const link = new URL(proposal.forumLink);
+
+  const description = matter.stringify(proposal.description, {
+    title: proposal.title,
+    topics: Array.from(proposal.topic.values()),
+    forumLink: link.toString(),
+    version: "1.0.0",
+    "content-encoding": "utf-8",
+    "content-type": "text/markdown",
+    actions: proposal.actions.map((action) => {
+      const actionMetadata: Record<string, string> = {
+        type: action.type,
+      };
+
+      if (action.type === ProposalTypeEnum.CUSTOM_PROPOSAL) {
+        actionMetadata.inputType = action.input!;
+      }
+
+      return actionMetadata;
+    }),
+  });
+
+  return [
+    proposal.actions.map((action) => action.target as `0x${string}`),
+    proposal.actions.map((action) => action.value ?? 0n),
+    actions,
+    description,
+  ] as const;
+};

package/src/actions/governance/getProposalVotes.ts

@@ -0,0 +1,20 @@
+import {
+  GetProposalVotes,
+  type GetProposalVotesQuery,
+  type GetProposalVotesQueryVariables,
+} from "@berachain/graphql/governance";
+
+import { getApolloClient } from "~/actions/clients/getApolloClient";
+
+export async function getProposalVotes({
+  variables,
+  ...args
+}: BeraJS.BaseFunctionArgs & {
+  variables: GetProposalVotesQueryVariables;
+}) {
+  const governanceClient = getApolloClient("governance.subgraph", args);
+  return governanceClient.query<GetProposalVotesQuery>({
+    query: GetProposalVotes,
+    variables,
+  });
+}

package/src/actions/governance/getQuorum.ts

@@ -0,0 +1,37 @@
+import { formatEther, type PublicClient } from "viem";
+
+import { governanceAbi } from "~/abi/governance/governance";
+import { assertPublicClient } from "~/errors/assert";
+import { parseBaseArgs } from "~/utils/parseBaseArgs";
+
+/**
+ * Queries the quorum for a given timestamp.
+ *
+ * @returns current quorum if timestamp is in the future.
+ */
+export async function getQuorum({
+  at,
+  publicClient,
+  ...args
+}: {
+  /**
+   * Timestamp in seconds
+   */
+  at?: number | string;
+  publicClient: PublicClient | undefined;
+} & BeraJS.BaseFunctionArgs): Promise<string> {
+  const { config } = parseBaseArgs(args);
+  assertPublicClient(publicClient);
+
+  const quorum = await publicClient.readContract({
+    address: config.governance.governor,
+    abi: governanceAbi,
+    functionName: "quorum",
+    // Needs to be pending or you'll get a ERC5805FutureLookup error when reading current quorum
+    // this is because now will always be in the future compared to the latest block
+    blockTag: "pending",
+    args: [BigInt(at ?? Math.floor(Date.now() / 1000))],
+  });
+
+  return formatEther(quorum);
+}

package/src/actions/governance/parseProposalBody.ts

@@ -0,0 +1,73 @@
+import graymatter from "gray-matter";
+
+import type { ProposalSelectionFragment } from "@berachain/graphql/governance";
+
+const parseLegacyBody = (
+  s: string,
+): { type: string | null; title: string; content: string } => {
+  const pattern = /#(?:([\w-]+)# )?(.+)\n([\s\S]*)/;
+  const match = s.match(pattern);
+
+  if (match) {
+    const type = match[1] || null;
+    const title = match[2];
+    const content = match[3].replace("\n", "<br />");
+    return {
+      type,
+      title,
+      content,
+    };
+  }
+
+  throw new Error("Invalid proposal body");
+};
+
+export const parseProposalBody = (
+  proposal?: Pick<ProposalSelectionFragment, "description">,
+): graymatter.GrayMatterFile<string> & {
+  isFrontMatter: boolean;
+} => {
+  if (!proposal) {
+    return {
+      isFrontMatter: false,
+      data: { title: "Loading..." },
+      content: "",
+      matter: "",
+      language: "",
+      orig: "",
+      stringify: () => "",
+    };
+  }
+
+  const body = proposal?.description ?? "";
+
+  if (graymatter.test(body)) {
+    return { ...graymatter(body), isFrontMatter: true };
+  }
+
+  try {
+    const legacyBody = parseLegacyBody(body);
+
+    return {
+      isFrontMatter: false,
+      data: { title: legacyBody.title },
+      content: legacyBody.content,
+      matter: "",
+      language: "",
+      orig: body,
+      stringify: () => body,
+    };
+  } catch {
+    return {
+      isFrontMatter: false,
+      data: {
+        title: proposal?.description?.split("\n")[0].slice(0, 100),
+      },
+      content: body,
+      matter: "",
+      language: "",
+      orig: body,
+      stringify: () => body,
+    };
+  }
+};

package/src/actions/honey/getChartData.ts

@@ -0,0 +1,27 @@
+import {
+  Aggregation_Interval,
+  GetChartData,
+  type GetChartDataQuery,
+  type GetChartDataQueryVariables,
+} from "@berachain/graphql/honey";
+
+import { getApolloClient } from "../clients/getApolloClient";
+export async function getChartData({
+  days,
+  ...args
+}: BeraJS.BaseFunctionArgs & {
+  days: number;
+}) {
+  const client = getApolloClient("honey.subgraph", args);
+
+  const res = await client.query<GetChartDataQuery, GetChartDataQueryVariables>(
+    {
+      query: GetChartData,
+      variables: {
+        interval: Aggregation_Interval.Day,
+        first: days,
+      },
+    },
+  );
+  return res.data;
+}