@berachain/berajs 0.1.0 → 0.1.2

package/src/actions/enso/zap.ts

@@ -0,0 +1,78 @@
+import type { BundleAction } from "@ensofinance/sdk";
+import { ethAddress, zeroAddress } from "viem";
+
+import { InvalidArgumentError } from "~/errors/InvalidArgumentError";
+import type {
+  GetZapTransactionRequestsArgs,
+  GetZapTransactionResponse,
+} from "~/types";
+import { getTransactionsFromBundle } from "./util";
+
+export async function getZapTransactionRequests({
+  fromAddress,
+  amountIn,
+  tokenIn,
+  tokenOut,
+  chainId,
+  ensoClient,
+  destinationChainId,
+  slippage,
+  publicClient,
+}: GetZapTransactionRequestsArgs): Promise<GetZapTransactionResponse> {
+  if (!fromAddress) {
+    throw new InvalidArgumentError({
+      property: "fromAddress",
+      value: fromAddress,
+      expected: "address",
+    });
+  }
+  if (tokenOut === zeroAddress) tokenOut = ethAddress;
+
+  const bundleAction: BundleAction = {
+    protocol: "enso",
+    action: "route",
+    args: {
+      tokenIn,
+      tokenOut,
+      amountIn,
+      slippage: slippage * 100, // Enso expects slippage in basis points
+    },
+  };
+  /**
+   * If the zap is cross chain, we need to add the destination chain id and the refund receiver.
+   *
+   * Enso still need to update the sdk types to support this.
+   */
+  if (destinationChainId && destinationChainId !== chainId) {
+    bundleAction.args = {
+      ...bundleAction.args,
+      //@ts-expect-error enso are releasing a fix in the next 2 weeks for this.
+      destinationChainId: destinationChainId,
+      refundReceiver: fromAddress,
+    };
+  }
+
+  const bundle = await ensoClient.getBundleData(
+    {
+      fromAddress: fromAddress,
+      receiver: fromAddress,
+      spender: fromAddress,
+      chainId: chainId,
+      routingStrategy: "router",
+    },
+    [bundleAction],
+  );
+  const transactions = await getTransactionsFromBundle({
+    fromAddress,
+    amountIn,
+    tokenIn,
+    chainId,
+    ensoClient,
+    bundle,
+    publicClient,
+  });
+  return {
+    bundle,
+    transactions,
+  };
+}

package/src/actions/governance/__tests__/checkProposalField.unit.test.ts

@@ -0,0 +1,108 @@
+import { describe, expect, it } from "vitest";
+
+import { parseBaseArgs } from "~/utils/parseBaseArgs";
+import { beraChefAbi } from "../../../abi/pol/beraChef";
+import { ProposalErrorCodes } from "../../../types/governance";
+import { checkProposalField } from "../checkProposalField";
+
+describe("checkProposalField", () => {
+  const { config } = parseBaseArgs({});
+  it("should check invalid address", () => {
+    expect(checkProposalField({ fieldOrType: "address", value: "0x123" })).toBe(
+      ProposalErrorCodes.INVALID_ADDRESS,
+    );
+    expect(
+      checkProposalField({
+        fieldOrType: "address",
+        value: config.pol.beraChef,
+      }),
+    ).toBe(null);
+    expect(
+      checkProposalField({
+        fieldOrType: "address",
+        value: config.pol.beraChef.toLowerCase(),
+      }),
+    ).toBe(null);
+  });
+
+  it.todo("should check invalid hex");
+
+  it.todo("should check invalid abi");
+
+  it.todo("should check invalid string");
+
+  it.todo("should check invalid bool");
+
+  it.todo("should check invalid action");
+
+  it.todo("should check invalid title");
+
+  it.todo("should check invalid forumLink");
+
+  it.todo("should check invalid description");
+
+  it.todo("should check invalid logoURI");
+
+  it.todo("should check invalid url");
+
+  it("should check invalid amount", () => {
+    expect(checkProposalField({ fieldOrType: "uint256", value: "100a0" })).toBe(
+      ProposalErrorCodes.INVALID_AMOUNT,
+    );
+
+    expect(
+      checkProposalField({ fieldOrType: "uint64", value: "100invalid" }),
+    ).toBe(ProposalErrorCodes.INVALID_AMOUNT);
+
+    expect(checkProposalField({ fieldOrType: "uint64", value: "-100" })).toBe(
+      ProposalErrorCodes.NEGATIVE_AMOUNT,
+    );
+
+    expect(checkProposalField({ fieldOrType: "int64", value: "-100" })).toBe(
+      null,
+    );
+
+    expect(checkProposalField({ fieldOrType: "uint256", value: "1000" })).toBe(
+      null,
+    );
+    expect(checkProposalField({ fieldOrType: "uint64", value: "1" })).toBe(
+      null,
+    );
+  });
+
+  it("should check nested fields", () => {
+    const abi = beraChefAbi.find(
+      (abi) =>
+        abi.type === "function" && abi.name === "setDefaultRewardAllocation",
+    );
+
+    if (!abi) {
+      throw new Error("BeraChef ABI not found");
+    }
+
+    const error = checkProposalField({
+      fieldOrType: abi.inputs[0].type,
+      value: {
+        startBlock: "0ds",
+        weights: [
+          {
+            receiver: "0x123",
+            percentageNumerator: "100a0",
+          },
+        ],
+      },
+
+      components: abi.inputs[0].components,
+    });
+
+    expect(error).toEqual({
+      startBlock: ProposalErrorCodes.INVALID_AMOUNT,
+      weights: [
+        {
+          percentageNumerator: ProposalErrorCodes.INVALID_AMOUNT,
+          receiver: ProposalErrorCodes.INVALID_ADDRESS,
+        },
+      ],
+    });
+  });
+});

package/src/actions/governance/__tests__/getDecodedFunctionData.integration.test.ts

@@ -0,0 +1,127 @@
+import { encodeFunctionData, zeroAddress } from "viem";
+import { describe, expect, it } from "vitest";
+
+import { ChainId, defaultChainId } from "@berachain/config/internal";
+
+import { beraChefAbi } from "~/abi/pol/beraChef";
+import { getServerSidePublicClient } from "~/utils/getServerSideClient";
+import { parseBaseArgs } from "~/utils/parseBaseArgs";
+import { getDecodedFunctionData } from "../getDecodedFunctionData";
+
+describe.skipIf(defaultChainId !== ChainId.MAINNET)(
+  "getDecodedFunctionData",
+
+  async () => {
+    const { config: chainConfig, chainId } = parseBaseArgs({});
+    const publicClient = getServerSidePublicClient();
+    it.concurrent("should match local abi", async () => {
+      const calldata = encodeFunctionData({
+        abi: beraChefAbi,
+        functionName: "isQueuedRewardAllocationReady",
+        args: ["0x00", 12345n],
+      });
+      const data = await getDecodedFunctionData({
+        address: zeroAddress,
+        publicClient,
+        callData: calldata,
+        chainId,
+      });
+
+      expect(data.functionSignature).toBe(
+        "isQueuedRewardAllocationReady(bytes,uint256)",
+      );
+      expect(data.abiItem).toBeDefined();
+      expect(data.args).toEqual(["0x00", 12345n]);
+      expect(data.functionName).toBe("isQueuedRewardAllocationReady");
+    });
+
+    // requires upgrade once we add more ABIs
+    it.concurrent(
+      "should match remote abi for immutable contract",
+      {
+        // Fails frequently on CI probably because of connection issues?
+        retry: 3,
+      },
+      async () => {
+        // setDefaultFeeBps(10)
+        const calldata =
+          "0x4488b652000000000000000000000000000000000000000000000000000000000000000a";
+        const data = await getDecodedFunctionData({
+          address: chainConfig.tokens.wbtc,
+          callData: calldata,
+          chainId,
+          publicClient,
+        });
+
+        expect(data.functionSignature).toBe("setDefaultFeeBps(uint16)");
+        expect(data.abiItem).toBeDefined();
+        expect(data.args).toEqual([10]);
+        expect(data.functionName).toBe("setDefaultFeeBps");
+      },
+    );
+
+    // requires upgrade once we add more ABIs
+    it.concurrent(
+      "should not match remote abi for wrong immutable contract",
+      async () => {
+        // setDefaultFeeBps(10)
+        const calldata =
+          "0x4488b652000000000000000000000000000000000000000000000000000000000000000a";
+        const data = await getDecodedFunctionData({
+          // purposely use a wrong contract, method is from wbtc
+          address: chainConfig.tokens.wbera,
+          callData: calldata,
+          chainId,
+          publicClient,
+        });
+
+        expect(data.args).toEqual([]);
+        expect(data.functionSignature).toBeUndefined();
+        expect(data.abiItem).toBeUndefined();
+        expect(data.functionName).toBeUndefined();
+      },
+    );
+
+    // requires upgrade once we add more ABIs
+    it.concurrent(
+      "should match remote abi for upgradeable contract",
+      async () => {
+        // mint(wbera, 100e18)
+        const calldata =
+          "0x40c10f1900000000000000000000000069696969696969696969696969696969696969690000000000000000000000000000000000000000000000056bc75e2d63100000";
+        const data = await getDecodedFunctionData({
+          address: chainConfig.honey.token,
+          callData: calldata,
+          chainId,
+          publicClient,
+        });
+
+        expect(data.functionSignature).toBe("mint(address,uint256)");
+        expect(data.abiItem).toBeDefined();
+        expect(data.args).toEqual([chainConfig.tokens.wbera, BigInt(100e18)]);
+        expect(data.functionName).toBe("mint");
+      },
+    );
+
+    // requires upgrade once we add more ABIs
+    it.concurrent(
+      "should not match remote abi for unverified/non-contract",
+      async () => {
+        // mint(wbera, 100e18)
+        const calldata =
+          "0x40c10f1900000000000000000000000069696969696969696969696969696969696969690000000000000000000000000000000000000000000000056bc75e2d63100000";
+        const data = await getDecodedFunctionData({
+          address: "0x000000000000000000000000000000000000dEaD",
+          callData: calldata,
+          chainId,
+          publicClient,
+        });
+
+        expect(data.args).toEqual([]);
+        expect(data.functionSignature).toBeUndefined();
+        expect(data.abiItem).toBeUndefined();
+        expect(data.functionName).toBeUndefined();
+      },
+    );
+  },
+);

package/src/actions/governance/__tests__/getQuorum.integration.test.ts

@@ -0,0 +1,39 @@
+import { describe, expect, it } from "vitest";
+
+import { ChainId, defaultChainId } from "@berachain/config/internal";
+
+import { getServerSidePublicClient } from "~/utils";
+import { getTestClient } from "~/utils/getTestClient";
+import { getQuorum } from "../getQuorum";
+
+describe("getQuorum", () => {
+  const publicClient = getServerSidePublicClient();
+
+  const quorums: Record<ChainId, Record<number, string>> = {
+    [ChainId.MAINNET]: {
+      1744113202: "1538677.785029999354705024",
+    },
+    [ChainId.BEPOLIA]: {
+      1748442752: "201123.520829556120148328",
+    },
+  } as const;
+
+  it.each(Object.entries(quorums[defaultChainId as ChainId]))(
+    "should match the quorum at %s",
+    async (at, shouldBe) => {
+      const quorum = await getQuorum({ publicClient, at });
+      expect(quorum).toBe(shouldBe);
+    },
+  );
+
+  it("should have a quorum for the current time", async () => {
+    const testClient = getTestClient();
+
+    await testClient.setNextBlockTimestamp({
+      timestamp: BigInt(Math.ceil(Date.now() / 1000)),
+    });
+
+    const quorum = await getQuorum({ publicClient });
+    expect(quorum).toBeDefined();
+  });
+});

package/src/actions/governance/checkProposalField.ts

@@ -0,0 +1,211 @@
+import { type AbiParameter, isAddress, isHex } from "viem";
+
+import { ProposalErrorCodes } from "~/types";
+
+type CheckProposalFieldResultMinimal = ProposalErrorCodes | null;
+
+type CheckProposalFieldResult =
+  | ProposalErrorCodes
+  | null
+  | CheckProposalFieldResultMinimal[]
+  | Record<string, CheckProposalFieldResultMinimal>;
+
+interface CheckProposalField {
+  (arg: {
+    fieldOrType:
+      | "address"
+      | "hex"
+      | "abi"
+      | "string"
+      | "bool"
+      | `uint${string}`
+      | `int${string}`
+      | "action"
+      | "title"
+      | "forumLink"
+      | "description"
+      | "logoURI"
+      | "url";
+    value: any;
+    required?: boolean;
+    baseUrl?: string;
+    components?: readonly (AbiParameter | readonly AbiParameter[])[];
+  }): CheckProposalFieldResultMinimal;
+  (arg: {
+    fieldOrType: "tuple[]" | "tuple";
+    value: any;
+    required?: boolean;
+    baseUrl?: string;
+    components?: readonly (AbiParameter | readonly AbiParameter[])[];
+  }): CheckProposalFieldResult;
+}
+// @ts-expect-error TODO: this is not typed, will throw if not valid
+export const checkProposalField: CheckProposalField = ({
+  fieldOrType,
+  value,
+  required = true,
+  baseUrl,
+  components,
+}) => {
+  const notRequiredAbiTypes = ["bool", "string"];
+
+  if (
+    !notRequiredAbiTypes.includes(fieldOrType) &&
+    required &&
+    (value === undefined || value === null || value === "")
+  ) {
+    return ProposalErrorCodes.REQUIRED;
+  }
+
+  if (fieldOrType.startsWith("uint") || fieldOrType.startsWith("int")) {
+    if (typeof value !== "string") {
+      return ProposalErrorCodes.INVALID_AMOUNT;
+    }
+
+    try {
+      const valueBN = BigInt(value);
+      if (fieldOrType.startsWith("uint")) {
+        if (valueBN < 0n) {
+          return ProposalErrorCodes.NEGATIVE_AMOUNT;
+        }
+      }
+    } catch {
+      return ProposalErrorCodes.INVALID_AMOUNT;
+    }
+    return null;
+  }
+
+  switch (fieldOrType) {
+    case "string":
+      if (value !== undefined && typeof value !== "string") {
+        return ProposalErrorCodes.INVALID_AMOUNT;
+      }
+      return null;
+
+    case "bool":
+      if (typeof value !== "boolean") {
+        return ProposalErrorCodes.INVALID_AMOUNT;
+      }
+      return null;
+
+    case "title":
+      if (value.length === 0) {
+        return ProposalErrorCodes.REQUIRED;
+      }
+      return null;
+
+    case "description":
+      if (value.length === 0) {
+        return ProposalErrorCodes.REQUIRED;
+      }
+      return null;
+
+    case "forumLink":
+      if (value.length === 0) {
+        return ProposalErrorCodes.REQUIRED;
+      }
+
+      if (!URL.canParse(value)) {
+        return ProposalErrorCodes.INVALID_ADDRESS;
+      }
+
+      // biome-ignore lint/correctness/noSwitchDeclarations: <explanation>
+      const base = new URL(baseUrl as string);
+
+      // base.pathname = "/c/";
+
+      if (!value.startsWith(base.toString())) {
+        return ProposalErrorCodes.INVALID_BASEPATH;
+      }
+
+      return null;
+
+    case "address":
+      if (!isAddress(value, { strict: true })) {
+        return ProposalErrorCodes.INVALID_ADDRESS;
+      }
+
+      return null;
+
+    case "hex":
+      if (!isHex(value, { strict: true })) {
+        return ProposalErrorCodes.INVALID_ADDRESS;
+      }
+      return null;
+
+    case "abi":
+      try {
+        JSON.parse(value);
+      } catch {
+        return ProposalErrorCodes.INVALID_ABI;
+      }
+      return null;
+
+    case "action":
+      if (!isAddress(value, { strict: true })) {
+        return ProposalErrorCodes.INVALID_ADDRESS;
+      }
+      return null;
+
+    case "tuple":
+      if (typeof value === "object" && Array.isArray(components)) {
+        const errors: Record<string, ProposalErrorCodes | null> = {};
+
+        for (const component of components) {
+          errors[component.name!] = checkProposalField({
+            fieldOrType: component.type,
+            value: value[component.name!],
+            components: component.components,
+          });
+        }
+
+        if (Object.values(errors).every((v) => v === null)) {
+          return null;
+        }
+
+        return errors;
+      }
+
+      return null;
+
+    case "tuple[]":
+      if (Array.isArray(value)) {
+        const errors = value.map((v) =>
+          checkProposalField({
+            fieldOrType: "tuple",
+            value: v,
+            components,
+          }),
+        );
+
+        if (errors.every((v) => v === null)) {
+          return null;
+        }
+
+        return errors;
+      }
+
+      return null;
+    case "logoURI": {
+      if (value === undefined || value === "") {
+        return null;
+      }
+      if (URL.canParse(value) && new URL(value).protocol === "https:") {
+        return null;
+      }
+      return ProposalErrorCodes.MUST_BE_HTTPS_OR_IPFS;
+    }
+    case "url": {
+      if (value === undefined || value === "") {
+        return null;
+      }
+      if (URL.canParse(value) && new URL(value).protocol === "https:") {
+        return null;
+      }
+      return ProposalErrorCodes.MUST_BE_HTTPS;
+    }
+    default:
+      console.error(`Invalid field or type: ${fieldOrType}`);
+      return null;
+  }
+};