@berachain/berajs 0.2.8-beta.9 → 0.2.10

package/dist/chunk-GUURQAME.mjs

@@ -0,0 +1,326 @@
+import {
+  assertPublicClient
+} from "./chunk-GY6B3PD5.mjs";
+
+// src/actions/governance/checkProposalField.ts
+import { isAddress, isHex } from "viem";
+function checkProposalField({
+  fieldOrType,
+  value,
+  required = true,
+  baseUrl,
+  components
+}) {
+  const notRequiredAbiTypes = ["bool", "string"];
+  if (!notRequiredAbiTypes.includes(fieldOrType) && required && (value === void 0 || value === null || value === "")) {
+    return "Required" /* REQUIRED */;
+  }
+  if (fieldOrType.startsWith("uint") || fieldOrType.startsWith("int")) {
+    if (typeof value !== "string") {
+      return "Invalid amount" /* INVALID_AMOUNT */;
+    }
+    try {
+      const valueBN = BigInt(value);
+      if (fieldOrType.startsWith("uint")) {
+        if (valueBN < 0n) {
+          return "Negative amount" /* NEGATIVE_AMOUNT */;
+        }
+      }
+    } catch {
+      return "Invalid amount" /* INVALID_AMOUNT */;
+    }
+    return null;
+  }
+  switch (fieldOrType) {
+    case "string":
+      if (value !== void 0 && typeof value !== "string") {
+        return "Invalid amount" /* INVALID_AMOUNT */;
+      }
+      return null;
+    case "bool":
+      if (typeof value !== "boolean") {
+        return "Invalid amount" /* INVALID_AMOUNT */;
+      }
+      return null;
+    case "title":
+      if (typeof value !== "string" || value.length === 0) {
+        return "Required" /* REQUIRED */;
+      }
+      return null;
+    case "description":
+      if (typeof value !== "string" || value.length === 0) {
+        return "Required" /* REQUIRED */;
+      }
+      return null;
+    case "forumLink": {
+      if (typeof value !== "string" || value.length === 0) {
+        return "Required" /* REQUIRED */;
+      }
+      if (!URL.canParse(value)) {
+        return "Invalid address" /* INVALID_ADDRESS */;
+      }
+      const base = new URL(baseUrl);
+      if (!value.startsWith(base.toString())) {
+        return "Must be a berachain forum link" /* INVALID_BASEPATH */;
+      }
+      return null;
+    }
+    case "address":
+      if (typeof value !== "string" || !isAddress(value, { strict: true })) {
+        return "Invalid address" /* INVALID_ADDRESS */;
+      }
+      return null;
+    case "hex":
+      if (typeof value !== "string" || !isHex(value, { strict: true })) {
+        return "Invalid address" /* INVALID_ADDRESS */;
+      }
+      return null;
+    case "abi":
+      if (typeof value !== "string") {
+        return "Invalid ABI" /* INVALID_ABI */;
+      }
+      try {
+        JSON.parse(value);
+      } catch {
+        return "Invalid ABI" /* INVALID_ABI */;
+      }
+      return null;
+    case "action":
+      if (typeof value !== "string" || !isAddress(value, { strict: true })) {
+        return "Invalid address" /* INVALID_ADDRESS */;
+      }
+      return null;
+    case "tuple":
+      if (typeof value === "object" && Array.isArray(components)) {
+        const errors = {};
+        for (const component of components) {
+          const abiParam = component;
+          const name = abiParam.name;
+          errors[name] = checkProposalField({
+            fieldOrType: abiParam.type,
+            value: value[name],
+            components: abiParam.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 === void 0 || value === "") {
+        return null;
+      }
+      if (typeof value !== "string" || !URL.canParse(value) || new URL(value).protocol !== "https:") {
+        return "Must be HTTPS or IPFS" /* MUST_BE_HTTPS_OR_IPFS */;
+      }
+      return null;
+    }
+    case "url": {
+      if (value === void 0 || value === "") {
+        return null;
+      }
+      if (typeof value !== "string" || !URL.canParse(value) || new URL(value).protocol !== "https:") {
+        return "Must be HTTPS" /* MUST_BE_HTTPS */;
+      }
+      return null;
+    }
+    default:
+      console.error(`Invalid field or type: ${fieldOrType}`);
+      return null;
+  }
+}
+
+// src/actions/governance/getAllProposals.ts
+async function getAllProposals(_args) {
+  return [];
+}
+
+// src/actions/governance/getBodyErrors.ts
+function getBodyErrors({
+  proposal,
+  currentTopic
+}) {
+  const e = {};
+  e.title = checkProposalField({
+    fieldOrType: "title",
+    value: proposal.title
+  });
+  e.description = checkProposalField({
+    fieldOrType: "description",
+    value: proposal.description
+  });
+  e.forumLink = checkProposalField({
+    fieldOrType: "forumLink",
+    value: proposal.forumLink,
+    baseUrl: currentTopic.forumLink
+  });
+  return e;
+}
+
+// src/actions/governance/getProposalDetails.ts
+async function getProposalDetails(_args) {
+  return void 0;
+}
+
+// src/actions/governance/parseProposalBody.ts
+import graymatter from "gray-matter";
+function parseLegacyBody(s) {
+  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");
+}
+function parseProposalBody(proposal) {
+  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
+    };
+  }
+}
+
+// src/actions/governance/getProposalFromTx.ts
+import {
+  parseEventLogs
+} from "viem";
+import { berachainGovernanceAbi as governanceAbi } from "@berachain/abis/gov/berachainGovernance";
+import {
+  ProposalStatus
+} from "@berachain/graphql/governance";
+async function getProposalFromTx(args) {
+  assertPublicClient(args.publicClient);
+  let tx;
+  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) : void 0;
+  if (!tx || !creationEvent) {
+    return null;
+  }
+  const block = await args.publicClient.getBlock({
+    blockNumber: tx.blockNumber
+  });
+  const fm = parseProposalBody({
+    description: creationEvent?.args.description
+  });
+  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,
+        value: String(creationEvent?.args.values[index]),
+        calldata: creationEvent?.args.calldatas[index]
+      })
+    ),
+    timelock: void 0
+  };
+}
+
+// src/actions/governance/getProposalVotes.ts
+async function getProposalVotes(_args) {
+  return { data: { votes: [] } };
+}
+
+export {
+  checkProposalField,
+  getAllProposals,
+  getBodyErrors,
+  getProposalDetails,
+  parseProposalBody,
+  getProposalFromTx,
+  getProposalVotes
+};

package/dist/chunk-GY6B3PD5.mjs

@@ -0,0 +1,89 @@
+import {
+  InvalidArgumentError
+} from "./chunk-KHXJDYA4.mjs";
+
+// src/errors/assert.ts
+import { isAddress } from "viem";
+function _isDefined(value) {
+  return value !== void 0 && value !== null;
+}
+function _assert({
+  value,
+  property,
+  fn
+}) {
+  const result = fn(value);
+  if (!result.isValid) {
+    throw new InvalidArgumentError({
+      property,
+      value,
+      expected: result.expectedType
+    });
+  }
+}
+function _assertDefined({
+  value,
+  property,
+  fn
+}) {
+  _assert({
+    value,
+    property,
+    fn: (value2) => {
+      const isDefined = _isDefined(value2);
+      const { isValid, expectedType } = fn(value2);
+      return {
+        expectedType,
+        isValid: isDefined && isValid
+      };
+    }
+  });
+}
+function assertDefined(value, property) {
+  _assertDefined({
+    value,
+    property,
+    fn: (value2) => ({ expectedType: "defined", isValid: _isDefined(value2) })
+  });
+}
+function assertPublicClient(value, property = "publicClient") {
+  assertDefined(value, property);
+}
+function assertAddress(value, property) {
+  _assertDefined({
+    value,
+    property,
+    fn: (value2) => ({
+      expectedType: "Address",
+      isValid: typeof value2 === "string" && isAddress(value2)
+    })
+  });
+}
+function assertPositive(value, property) {
+  const isPositive = typeof value === "bigint" ? value > 0n : Number(value) > 0;
+  if (!isPositive) {
+    throw new InvalidArgumentError({
+      property,
+      value,
+      expected: "positive amount"
+    });
+  }
+}
+function assertAmount(value, property) {
+  _assertDefined({
+    value,
+    property,
+    fn: (value2) => ({
+      expectedType: "number",
+      isValid: (typeof value2 === "string" || typeof value2 === "number") && Number(value2) > 0
+    })
+  });
+}
+
+export {
+  assertDefined,
+  assertPublicClient,
+  assertAddress,
+  assertPositive,
+  assertAmount
+};

package/dist/chunk-HQCOU6GY.mjs

@@ -0,0 +1,243 @@
+// src/abi/utils/multicall3.ts
+var multicall3Abi = [
+  {
+    inputs: [
+      {
+        components: [
+          { internalType: "address", name: "target", type: "address" },
+          { internalType: "bytes", name: "callData", type: "bytes" }
+        ],
+        internalType: "struct Multicall3.Call[]",
+        name: "calls",
+        type: "tuple[]"
+      }
+    ],
+    name: "aggregate",
+    outputs: [
+      { internalType: "uint256", name: "blockNumber", type: "uint256" },
+      { internalType: "bytes[]", name: "returnData", type: "bytes[]" }
+    ],
+    stateMutability: "payable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        components: [
+          { internalType: "address", name: "target", type: "address" },
+          { internalType: "bool", name: "allowFailure", type: "bool" },
+          { internalType: "bytes", name: "callData", type: "bytes" }
+        ],
+        internalType: "struct Multicall3.Call3[]",
+        name: "calls",
+        type: "tuple[]"
+      }
+    ],
+    name: "aggregate3",
+    outputs: [
+      {
+        components: [
+          { internalType: "bool", name: "success", type: "bool" },
+          { internalType: "bytes", name: "returnData", type: "bytes" }
+        ],
+        internalType: "struct Multicall3.Result[]",
+        name: "returnData",
+        type: "tuple[]"
+      }
+    ],
+    stateMutability: "payable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        components: [
+          { internalType: "address", name: "target", type: "address" },
+          { internalType: "bool", name: "allowFailure", type: "bool" },
+          { internalType: "uint256", name: "value", type: "uint256" },
+          { internalType: "bytes", name: "callData", type: "bytes" }
+        ],
+        internalType: "struct Multicall3.Call3Value[]",
+        name: "calls",
+        type: "tuple[]"
+      }
+    ],
+    name: "aggregate3Value",
+    outputs: [
+      {
+        components: [
+          { internalType: "bool", name: "success", type: "bool" },
+          { internalType: "bytes", name: "returnData", type: "bytes" }
+        ],
+        internalType: "struct Multicall3.Result[]",
+        name: "returnData",
+        type: "tuple[]"
+      }
+    ],
+    stateMutability: "payable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        components: [
+          { internalType: "address", name: "target", type: "address" },
+          { internalType: "bytes", name: "callData", type: "bytes" }
+        ],
+        internalType: "struct Multicall3.Call[]",
+        name: "calls",
+        type: "tuple[]"
+      }
+    ],
+    name: "blockAndAggregate",
+    outputs: [
+      { internalType: "uint256", name: "blockNumber", type: "uint256" },
+      { internalType: "bytes32", name: "blockHash", type: "bytes32" },
+      {
+        components: [
+          { internalType: "bool", name: "success", type: "bool" },
+          { internalType: "bytes", name: "returnData", type: "bytes" }
+        ],
+        internalType: "struct Multicall3.Result[]",
+        name: "returnData",
+        type: "tuple[]"
+      }
+    ],
+    stateMutability: "payable",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "getBasefee",
+    outputs: [{ internalType: "uint256", name: "basefee", type: "uint256" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [{ internalType: "uint256", name: "blockNumber", type: "uint256" }],
+    name: "getBlockHash",
+    outputs: [{ internalType: "bytes32", name: "blockHash", type: "bytes32" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "getBlockNumber",
+    outputs: [
+      { internalType: "uint256", name: "blockNumber", type: "uint256" }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "getChainId",
+    outputs: [{ internalType: "uint256", name: "chainid", type: "uint256" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "getCurrentBlockCoinbase",
+    outputs: [{ internalType: "address", name: "coinbase", type: "address" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "getCurrentBlockDifficulty",
+    outputs: [{ internalType: "uint256", name: "difficulty", type: "uint256" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "getCurrentBlockGasLimit",
+    outputs: [{ internalType: "uint256", name: "gaslimit", type: "uint256" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "getCurrentBlockTimestamp",
+    outputs: [{ internalType: "uint256", name: "timestamp", type: "uint256" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [{ internalType: "address", name: "addr", type: "address" }],
+    name: "getEthBalance",
+    outputs: [{ internalType: "uint256", name: "balance", type: "uint256" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "getLastBlockHash",
+    outputs: [{ internalType: "bytes32", name: "blockHash", type: "bytes32" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "bool", name: "requireSuccess", type: "bool" },
+      {
+        components: [
+          { internalType: "address", name: "target", type: "address" },
+          { internalType: "bytes", name: "callData", type: "bytes" }
+        ],
+        internalType: "struct Multicall3.Call[]",
+        name: "calls",
+        type: "tuple[]"
+      }
+    ],
+    name: "tryAggregate",
+    outputs: [
+      {
+        components: [
+          { internalType: "bool", name: "success", type: "bool" },
+          { internalType: "bytes", name: "returnData", type: "bytes" }
+        ],
+        internalType: "struct Multicall3.Result[]",
+        name: "returnData",
+        type: "tuple[]"
+      }
+    ],
+    stateMutability: "payable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "bool", name: "requireSuccess", type: "bool" },
+      {
+        components: [
+          { internalType: "address", name: "target", type: "address" },
+          { internalType: "bytes", name: "callData", type: "bytes" }
+        ],
+        internalType: "struct Multicall3.Call[]",
+        name: "calls",
+        type: "tuple[]"
+      }
+    ],
+    name: "tryBlockAndAggregate",
+    outputs: [
+      { internalType: "uint256", name: "blockNumber", type: "uint256" },
+      { internalType: "bytes32", name: "blockHash", type: "bytes32" },
+      {
+        components: [
+          { internalType: "bool", name: "success", type: "bool" },
+          { internalType: "bytes", name: "returnData", type: "bytes" }
+        ],
+        internalType: "struct Multicall3.Result[]",
+        name: "returnData",
+        type: "tuple[]"
+      }
+    ],
+    stateMutability: "payable",
+    type: "function"
+  }
+];
+
+export {
+  multicall3Abi
+};