@bananapus/nana-sdk-react 1.0.0

package/dist/index.js

@@ -0,0 +1,1676 @@
+// src/components/NativeTokenValue.tsx
+import { NATIVE_TOKEN_DECIMALS, formatUnits } from "@bananapus/nana-sdk-core";
+
+// src/hooks/token/useNativeTokenSymbol.ts
+import { DEFAULT_NATIVE_TOKEN_SYMBOL, JB_CHAINS } from "@bananapus/nana-sdk-core";
+
+// src/contexts/JBChainContext/JBChainContext.tsx
+import { debug } from "@bananapus/nana-sdk-core";
+import { createContext, useContext } from "react";
+import { jsx } from "react/jsx-runtime";
+var JBChainContext = createContext({
+  chainId: void 0
+});
+function useJBChainId() {
+  const { chainId } = useContext(JBChainContext);
+  return chainId;
+}
+var JBChainProvider = ({
+  chainId,
+  children
+}) => {
+  debug("JBChainContext", { chainId });
+  return /* @__PURE__ */ jsx(JBChainContext.Provider, { value: { chainId }, children });
+};
+
+// src/hooks/token/useNativeTokenSymbol.ts
+function useNativeTokenSymbol(chainId) {
+  const _chainId = chainId ?? useJBChainId();
+  if (!_chainId) {
+    return DEFAULT_NATIVE_TOKEN_SYMBOL;
+  }
+  return JB_CHAINS[_chainId]?.nativeTokenSymbol ?? DEFAULT_NATIVE_TOKEN_SYMBOL;
+}
+
+// src/components/NativeTokenValue.tsx
+import { Fragment, jsxs } from "react/jsx-runtime";
+function NativeTokenValue({ wei, decimals = 4 }) {
+  const symbol = useNativeTokenSymbol();
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    formatUnits(wei, NATIVE_TOKEN_DECIMALS, {
+      fractionDigits: decimals
+    }),
+    " ",
+    symbol
+  ] });
+}
+
+// src/contexts/JBContractContext/JBContractContext.tsx
+import {
+  NATIVE_TOKEN as NATIVE_TOKEN4,
+  debug as debug10,
+  USDC_ADDRESSES,
+  jbDirectoryAbi,
+  jbControllerAbi as jbControllerAbi5,
+  jbContractAddress as jbContractAddress2,
+  JBCoreContracts as JBCoreContracts3,
+  getJBContractAddress as getJBContractAddress2
+} from "@bananapus/nana-sdk-core";
+import { createContext as createContext8, useCallback, useContext as useContext8, useMemo as useMemo3 } from "react";
+import { isAddressEqual as isAddressEqual4, zeroAddress as zeroAddress4 } from "viem";
+
+// src/hooks/usePreparePayMetadata.ts
+import { DEFAULT_ALLOW_OVERSPENDING, createHookMetadata } from "@bananapus/nana-sdk-core";
+import { encodeAbiParameters } from "viem";
+
+// src/hooks/jb721Hook/helpers.ts
+import { bytesToHex, keccak256, toBytes } from "viem";
+function createMetadataTargetIdPayHash(metadataTargetId, purpose = "pay") {
+  const targetBytes = toBytes(metadataTargetId);
+  const purposeBytes = toBytes(purpose);
+  const targetBytes20 = targetBytes.slice(0, 20);
+  const purposeBytes20 = toBytes(keccak256(purposeBytes)).slice(0, 20);
+  const xorResult = targetBytes20.map((byte, i) => byte ^ purposeBytes20[i]);
+  return bytesToHex(xorResult.slice(0, 4));
+}
+
+// src/hooks/jb721Hook/use721HookMetadataId.tsx
+import { jb721TiersHookAbi } from "@bananapus/nana-sdk-core";
+import { useReadContract } from "wagmi";
+function use721HookMetadataId({
+  dataHookAddress
+}) {
+  const chainId = useJBChainId();
+  const { data: hashedMetadataId } = useReadContract({
+    abi: jb721TiersHookAbi,
+    functionName: "METADATA_ID_TARGET",
+    chainId,
+    address: dataHookAddress,
+    query: {
+      enabled: !!dataHookAddress,
+      select(metadataTargetId) {
+        return createMetadataTargetIdPayHash(metadataTargetId, "pay");
+      }
+    }
+  });
+  return hashedMetadataId;
+}
+
+// src/hooks/usePreparePayMetadata.ts
+import { debug as debug2 } from "@bananapus/nana-sdk-core";
+function encodeJB721HookPayMetadata(metadata) {
+  const args = [
+    metadata.allowOverspending ?? DEFAULT_ALLOW_OVERSPENDING,
+    metadata.tierIdsToMint.map(Number)
+  ];
+  const encoded = encodeAbiParameters([{ type: "bool" }, { type: "uint16[]" }], args);
+  return encoded;
+}
+function usePreparePayMetadata({
+  jb721Hook
+} = {}) {
+  const HookIds = [];
+  const metadatas = [];
+  const metadataId = use721HookMetadataId({
+    dataHookAddress: jb721Hook?.dataHookAddress
+  });
+  debug2("usePreparePayMetadata", { metadataId, jb721Hook });
+  if (!jb721Hook || jb721Hook.tierIdsToMint.length == 0 || !metadataId) {
+    return null;
+  }
+  const jb721HookMetadata = encodeJB721HookPayMetadata({
+    tierIdsToMint: jb721Hook.tierIdsToMint,
+    allowOverspending: DEFAULT_ALLOW_OVERSPENDING
+  });
+  HookIds.push(metadataId);
+  metadatas.push(jb721HookMetadata);
+  return createHookMetadata(HookIds, metadatas);
+}
+
+// src/hooks/useNetwork.ts
+import { useAccount, useClient } from "wagmi";
+function useChain() {
+  const { chain } = useAccount();
+  const client = useClient();
+  return chain ?? client?.chain;
+}
+
+// src/hooks/jb721Hook/useFind721DataHook.tsx
+import { find721DataHook } from "@bananapus/nana-sdk-core";
+import { usePublicClient } from "wagmi";
+import { useQuery } from "wagmi/query";
+
+// src/contexts/JBRulesetContext/JBRulesetContext.tsx
+import {
+  CashOutTaxRate,
+  debug as debug3,
+  jbControllerAbi,
+  ReservedPercent,
+  RulesetWeight,
+  WeightCutPercent
+} from "@bananapus/nana-sdk-core";
+import { createContext as createContext2, useContext as useContext2 } from "react";
+import { useReadContract as useReadContract3 } from "wagmi";
+
+// src/hooks/ruleset/useResolveDataHook.ts
+import {
+  jbContractAddress,
+  jbOmnichainDeployer4_1Abi,
+  jbOmnichainDeployerAbi,
+  jbOmnichainDeployerV5Abi
+} from "@bananapus/nana-sdk-core";
+import { isAddressEqual, zeroAddress } from "viem";
+import { mainnet } from "viem/chains";
+import { useReadContract as useReadContract2 } from "wagmi";
+function useResolveDataHook({
+  dataHookAddress,
+  projectId,
+  chainId,
+  rulesetId
+}) {
+  const { version } = useJBContractContext();
+  const omnichainDeployerAddress = version === 4 ? jbContractAddress[4]["JBOmnichainDeployer4_1"][mainnet.id] : jbContractAddress[version]["JBOmnichainDeployer"][mainnet.id];
+  const dataHookIsOmnichainDeployer = Boolean(
+    dataHookAddress && isAddressEqual(dataHookAddress, omnichainDeployerAddress)
+  );
+  const args = projectId && rulesetId ? [projectId, rulesetId] : void 0;
+  const legacyDataHookQuery = useReadContract2({
+    abi: version === 4 ? jbOmnichainDeployer4_1Abi : jbOmnichainDeployerV5Abi,
+    functionName: "dataHookOf",
+    address: omnichainDeployerAddress,
+    chainId,
+    args,
+    query: {
+      enabled: version !== 6 && !!dataHookIsOmnichainDeployer && !!projectId
+    }
+  });
+  const tiered721HookQuery = useReadContract2({
+    abi: jbOmnichainDeployerAbi,
+    functionName: "tiered721HookOf",
+    address: omnichainDeployerAddress,
+    chainId,
+    args,
+    query: {
+      enabled: version === 6 && !!dataHookIsOmnichainDeployer && !!projectId
+    }
+  });
+  const extraDataHookQuery = useReadContract2({
+    abi: jbOmnichainDeployerAbi,
+    functionName: "extraDataHookOf",
+    address: omnichainDeployerAddress,
+    chainId,
+    args,
+    query: {
+      enabled: version === 6 && !!dataHookIsOmnichainDeployer && !!projectId
+    }
+  });
+  const isLoading = version === 6 ? tiered721HookQuery.isLoading || extraDataHookQuery.isLoading : legacyDataHookQuery.isLoading;
+  const error = version === 6 ? tiered721HookQuery.error ?? extraDataHookQuery.error : legacyDataHookQuery.error;
+  if (!dataHookAddress)
+    return {
+      resolvedDataHook: zeroAddress,
+      dataHookIsOmnichainDeployer,
+      isLoading,
+      error
+    };
+  let resolvedDataHook = dataHookAddress;
+  if (dataHookIsOmnichainDeployer) {
+    if (version === 6) {
+      const tiered721Hook = tiered721HookQuery.data?.[0];
+      const extraDataHook = extraDataHookQuery.data?.dataHook;
+      if (tiered721Hook && !isAddressEqual(tiered721Hook, zeroAddress)) {
+        resolvedDataHook = tiered721Hook;
+      } else if (extraDataHook && !isAddressEqual(extraDataHook, zeroAddress)) {
+        resolvedDataHook = extraDataHook;
+      }
+    } else if (legacyDataHookQuery.data?.[2]) {
+      resolvedDataHook = legacyDataHookQuery.data[2];
+    }
+  }
+  return {
+    resolvedDataHook,
+    dataHookIsOmnichainDeployer,
+    isLoading,
+    error
+  };
+}
+
+// src/contexts/types.ts
+var AsyncDataNone = {
+  isLoading: false,
+  data: void 0
+};
+
+// src/contexts/JBRulesetContext/JBRulesetContext.tsx
+import { jsx as jsx2 } from "react/jsx-runtime";
+var JBRulesetContext = createContext2({
+  ruleset: AsyncDataNone,
+  rulesetMetadata: AsyncDataNone
+});
+function useJBRulesetContext() {
+  return useContext2(JBRulesetContext);
+}
+function useJBRulesetMetadata() {
+  const { rulesetMetadata } = useJBRulesetContext();
+  return rulesetMetadata;
+}
+var JBRulesetProvider = ({ children }) => {
+  const { contracts, projectId, version } = useJBContractContext();
+  const chainId = useJBChainId();
+  const { data: ruleset, isLoading } = useReadContract3({
+    chainId,
+    abi: jbControllerAbi,
+    functionName: "currentRulesetOf",
+    address: contracts.controller.data ?? void 0,
+    args: [projectId],
+    query: {
+      select([ruleset2, rulesetMetadata]) {
+        return {
+          data: {
+            ...ruleset2,
+            weight: new RulesetWeight(ruleset2.weight),
+            weightCutPercent: new WeightCutPercent(ruleset2.weightCutPercent)
+          },
+          metadata: {
+            ...rulesetMetadata,
+            cashOutTaxRate: new CashOutTaxRate(rulesetMetadata.cashOutTaxRate),
+            reservedPercent: new ReservedPercent(rulesetMetadata.reservedPercent),
+            // v4/v5 store the INVERSE flag (`useTotalSurplusForCashOuts`) in this slot;
+            // normalize to the v6 field's semantics.
+            scopeCashOutsToLocalBalances: version === 6 ? rulesetMetadata.scopeCashOutsToLocalBalances : !rulesetMetadata.scopeCashOutsToLocalBalances
+          }
+        };
+      }
+    }
+  });
+  const { resolvedDataHook } = useResolveDataHook({
+    dataHookAddress: ruleset?.metadata?.dataHook,
+    projectId,
+    chainId,
+    rulesetId: BigInt(ruleset?.data.id ?? 0)
+  });
+  const rulesetMetadataWithResolvedDataHook = ruleset?.metadata && {
+    ...ruleset.metadata,
+    dataHook: resolvedDataHook
+  };
+  debug3("JBRulesetContext", {
+    ruleset: {
+      data: ruleset?.data,
+      isLoading
+    },
+    rulesetMetadata: {
+      data: rulesetMetadataWithResolvedDataHook,
+      isLoading
+    }
+  });
+  return /* @__PURE__ */ jsx2(
+    JBRulesetContext.Provider,
+    {
+      value: {
+        ruleset: {
+          data: ruleset?.data,
+          isLoading
+        },
+        rulesetMetadata: {
+          data: rulesetMetadataWithResolvedDataHook,
+          isLoading
+        }
+      },
+      children
+    }
+  );
+};
+
+// src/contexts/JBDataHookContext/JBDataHookContext.tsx
+import { createContext as createContext3, useContext as useContext3, useMemo } from "react";
+import { debug as debug4 } from "@bananapus/nana-sdk-core";
+import { jsx as jsx3 } from "react/jsx-runtime";
+var JBDataHookContext = createContext3(AsyncDataNone);
+function useJBDataHookContext() {
+  return useContext3(JBDataHookContext);
+}
+var JBDataHookProvider = ({
+  dataHookAddress,
+  children
+}) => {
+  const data = useMemo(() => {
+    if (!dataHookAddress) {
+      return AsyncDataNone;
+    }
+    return {
+      isLoading: false,
+      data: {
+        dataHookAddress
+      }
+    };
+  }, [dataHookAddress]);
+  debug4("JBDataHookContext", data);
+  return /* @__PURE__ */ jsx3(JBDataHookContext.Provider, { value: data, children });
+};
+
+// src/hooks/jb721Hook/useFind721DataHook.tsx
+import { debug as debug5 } from "@bananapus/nana-sdk-core";
+function useFind721DataHook() {
+  const { data } = useJBDataHookContext();
+  const { projectId, version } = useJBContractContext();
+  const { ruleset } = useJBRulesetContext();
+  const publicClient = usePublicClient();
+  const rulesetId = ruleset.data?.id;
+  const dataHookAddress = data?.dataHookAddress;
+  debug5("useFind721DataHook::args", {
+    projectId,
+    rulesetId,
+    dataHookAddress,
+    publicClient
+  });
+  const jb721DataHookQuery = useQuery({
+    queryKey: ["dataHook", projectId, rulesetId, dataHookAddress],
+    staleTime: Infinity,
+    queryFn: async () => {
+      if (!rulesetId || !dataHookAddress) return null;
+      if (!publicClient) {
+        throw new Error("Public client not available.");
+      }
+      const jb721DataHook = await find721DataHook(publicClient, {
+        dataHookAddress,
+        projectId,
+        rulesetId,
+        version
+      });
+      return jb721DataHook;
+    }
+  });
+  return jb721DataHookQuery;
+}
+
+// src/hooks/suckers/useSuckers.ts
+import { debug as debug9 } from "@bananapus/nana-sdk-core";
+
+// src/generated/graphql.ts
+var ProjectDocument = { "kind": "Document", "definitions": [{ "kind": "OperationDefinition", "operation": "query", "name": { "kind": "Name", "value": "Project" }, "variableDefinitions": [{ "kind": "VariableDefinition", "variable": { "kind": "Variable", "name": { "kind": "Name", "value": "projectId" } }, "type": { "kind": "NonNullType", "type": { "kind": "NamedType", "name": { "kind": "Name", "value": "Float" } } } }, { "kind": "VariableDefinition", "variable": { "kind": "Variable", "name": { "kind": "Name", "value": "chainId" } }, "type": { "kind": "NonNullType", "type": { "kind": "NamedType", "name": { "kind": "Name", "value": "Float" } } } }, { "kind": "VariableDefinition", "variable": { "kind": "Variable", "name": { "kind": "Name", "value": "version" } }, "type": { "kind": "NonNullType", "type": { "kind": "NamedType", "name": { "kind": "Name", "value": "Float" } } } }], "selectionSet": { "kind": "SelectionSet", "selections": [{ "kind": "Field", "name": { "kind": "Name", "value": "project" }, "arguments": [{ "kind": "Argument", "name": { "kind": "Name", "value": "projectId" }, "value": { "kind": "Variable", "name": { "kind": "Name", "value": "projectId" } } }, { "kind": "Argument", "name": { "kind": "Name", "value": "chainId" }, "value": { "kind": "Variable", "name": { "kind": "Name", "value": "chainId" } } }, { "kind": "Argument", "name": { "kind": "Name", "value": "version" }, "value": { "kind": "Variable", "name": { "kind": "Name", "value": "version" } } }], "selectionSet": { "kind": "SelectionSet", "selections": [{ "kind": "Field", "name": { "kind": "Name", "value": "projectId" } }, { "kind": "Field", "name": { "kind": "Name", "value": "metadataUri" } }, { "kind": "Field", "name": { "kind": "Name", "value": "handle" } }, { "kind": "Field", "name": { "kind": "Name", "value": "createdAt" } }, { "kind": "Field", "name": { "kind": "Name", "value": "logoUri" } }, { "kind": "Field", "name": { "kind": "Name", "value": "name" } }, { "kind": "Field", "name": { "kind": "Name", "value": "version" } }, { "kind": "Field", "name": { "kind": "Name", "value": "suckerGroupId" } }, { "kind": "Field", "name": { "kind": "Name", "value": "suckerGroup" }, "selectionSet": { "kind": "SelectionSet", "selections": [{ "kind": "Field", "name": { "kind": "Name", "value": "projects" }, "selectionSet": { "kind": "SelectionSet", "selections": [{ "kind": "Field", "name": { "kind": "Name", "value": "items" }, "selectionSet": { "kind": "SelectionSet", "selections": [{ "kind": "Field", "name": { "kind": "Name", "value": "chainId" } }, { "kind": "Field", "name": { "kind": "Name", "value": "balance" } }, { "kind": "Field", "name": { "kind": "Name", "value": "tokenSupply" } }, { "kind": "Field", "name": { "kind": "Name", "value": "projectId" } }] } }] } }] } }] } }] } }] };
+
+// src/lib/bendystraw/useBendystrawQuery.ts
+import { useQuery as useQuery3 } from "@tanstack/react-query";
+import request from "graphql-request";
+
+// src/lib/bendystraw/getBendystrawUrl.ts
+import { arbitrum, base, mainnet as mainnet2, optimism } from "viem/chains";
+var bendystrawUrl = "https://bendystraw.xyz";
+var testnetBendystrawUrl = "https://testnet.bendystraw.xyz";
+function getBendystrawUrl(chainId, config) {
+  const { url, apiKey } = config;
+  if (url) return `${url}/${apiKey}`;
+  const isMainnet = [mainnet2, base, arbitrum, optimism].some((c) => c.id === chainId);
+  return `${isMainnet ? bendystrawUrl : testnetBendystrawUrl}${apiKey !== "" ? `/${apiKey}` : ""}`;
+}
+
+// src/contexts/JBProjectProvider/JBProjectProvider.tsx
+import { createContext as createContext7, useContext as useContext7 } from "react";
+
+// src/contexts/JBDataHookContext/JBCurrentDataHookProvider.tsx
+import { debug as debug6 } from "@bananapus/nana-sdk-core";
+import { jsx as jsx4 } from "react/jsx-runtime";
+function JBCurrentDataHookProvider({
+  children
+}) {
+  const { data } = useJBRulesetMetadata();
+  const dataHookAddress = data?.dataHook;
+  debug6("JBCurrentDataHookContext", { dataHookAddress });
+  return /* @__PURE__ */ jsx4(JBDataHookProvider, { dataHookAddress, children });
+}
+
+// src/contexts/JBProjectMetadataContext/JBProjectMetadataContext.tsx
+import { debug as debug7, getProjectMetadata } from "@bananapus/nana-sdk-core";
+import { createContext as createContext4, useContext as useContext4 } from "react";
+import { usePublicClient as usePublicClient2 } from "wagmi";
+import { useQuery as useQuery2 } from "wagmi/query";
+import { jsx as jsx5 } from "react/jsx-runtime";
+var JBProjectMetadataContext = createContext4({
+  metadata: AsyncDataNone
+});
+function useJBProjectMetadataContext() {
+  return useContext4(JBProjectMetadataContext);
+}
+function useProjectMetadata({
+  projectId,
+  jbControllerAddress,
+  ipfsGatewayHostname
+}) {
+  const chainId = useJBChainId();
+  const publicClient = usePublicClient2({ chainId });
+  return useQuery2({
+    queryKey: [
+      "juice-sdk",
+      "useProjectMetadata",
+      projectId?.toString(),
+      jbControllerAddress,
+      ipfsGatewayHostname
+    ],
+    queryFn: async () => {
+      if (!projectId || !jbControllerAddress) return null;
+      if (!publicClient) {
+        throw new Error("Public client not available.");
+      }
+      const response = await getProjectMetadata(
+        publicClient,
+        {
+          projectId,
+          jbControllerAddress
+        },
+        {
+          ipfsGatewayHostname
+        }
+      );
+      return response ?? null;
+    }
+  });
+}
+var JBProjectMetadataProvider = ({
+  children,
+  ipfsGatewayHostname
+}) => {
+  const { projectId, contracts } = useJBContractContext();
+  const metadata = useProjectMetadata({
+    projectId,
+    jbControllerAddress: contracts.controller.data ?? void 0,
+    ipfsGatewayHostname
+  });
+  debug7("JBProjectMetadataContext", {
+    projectId,
+    ipfsGatewayHostname,
+    contracts,
+    metadata
+  });
+  return /* @__PURE__ */ jsx5(
+    JBProjectMetadataContext.Provider,
+    {
+      value: { metadata },
+      children
+    }
+  );
+};
+
+// src/contexts/JBTokenContext/JBTokenContext.tsx
+import {
+  getJBContractAddress,
+  jbControllerAbi as jbControllerAbi2,
+  JBCoreContracts,
+  JBProjectToken,
+  jbTokensAbi
+} from "@bananapus/nana-sdk-core";
+import { createContext as createContext5, useContext as useContext5 } from "react";
+import { isAddressEqual as isAddressEqual2, zeroAddress as zeroAddress2 } from "viem";
+import { useReadContract as useReadContract4, useToken } from "wagmi";
+import { jsx as jsx6 } from "react/jsx-runtime";
+var JBTokenContext = createContext5({
+  /**
+   * The token of the project.
+   *
+   * @default none {@link AsyncDataNone}
+   */
+  token: AsyncDataNone,
+  /**
+   * The total outstanding tokens of the project.
+   *
+   * @default none {@link AsyncDataNone}
+   */
+  totalOutstanding: AsyncDataNone
+});
+function useJBTokenContext() {
+  return useContext5(JBTokenContext);
+}
+var JBTokenProvider = ({ children, withTotalOutstanding }) => {
+  const chainId = useJBChainId();
+  const {
+    projectId,
+    version,
+    contracts: { controller }
+  } = useJBContractContext();
+  const { data: tokenAddress } = useReadContract4({
+    address: getJBContractAddress(JBCoreContracts.JBTokens, version, chainId),
+    abi: jbTokensAbi,
+    functionName: "tokenOf",
+    chainId,
+    args: [projectId],
+    query: { enabled: !!projectId && !!chainId && !!version }
+  });
+  const fetchTokenEnabled = Boolean(tokenAddress && !isAddressEqual2(tokenAddress, zeroAddress2));
+  const token = useToken({
+    chainId,
+    address: fetchTokenEnabled ? tokenAddress : void 0,
+    query: { enabled: fetchTokenEnabled }
+  });
+  const totalOutstandingRes = useReadContract4({
+    abi: jbControllerAbi2,
+    functionName: "totalTokenSupplyWithReservedTokensOf",
+    chainId,
+    address: controller?.data ?? void 0,
+    args: withTotalOutstanding ? [projectId] : void 0,
+    query: {
+      enabled: withTotalOutstanding && controller?.data !== void 0
+    }
+  });
+  const totalOutstandingData = totalOutstandingRes?.data ? new JBProjectToken(totalOutstandingRes?.data) : void 0;
+  return /* @__PURE__ */ jsx6(
+    JBTokenContext.Provider,
+    {
+      value: {
+        token,
+        totalOutstanding: {
+          data: totalOutstandingData,
+          isLoading: totalOutstandingRes?.isLoading
+        }
+      },
+      children
+    }
+  );
+};
+
+// src/contexts/JBTerminalContext/JBPrimaryNativeTerminalProvider.tsx
+import { debug as debug8 } from "@bananapus/nana-sdk-core";
+
+// src/contexts/JBTerminalContext/JBTerminalContext.tsx
+import { jbMultiTerminalAbi } from "@bananapus/nana-sdk-core";
+import { createContext as createContext6, useContext as useContext6 } from "react";
+import { isAddressEqual as isAddressEqual3, zeroAddress as zeroAddress3 } from "viem";
+import { useReadContract as useReadContract5 } from "wagmi";
+import { jsx as jsx7 } from "react/jsx-runtime";
+var JBTerminalContext = createContext6({
+  address: void 0,
+  accountingContexts: AsyncDataNone,
+  store: AsyncDataNone
+});
+function useJBTerminalContext() {
+  return useContext6(JBTerminalContext);
+}
+var JBTerminalProvider = ({ address, children }) => {
+  const chainId = useJBChainId();
+  const { data: store, isLoading: isStoreLoading } = useReadContract5({
+    abi: jbMultiTerminalAbi,
+    functionName: "STORE",
+    chainId,
+    address: address && isAddressEqual3(address, zeroAddress3) ? void 0 : address
+  });
+  const { data: accountingContexts, isLoading: accountingContextsLoading } = useReadContract5({
+    abi: jbMultiTerminalAbi,
+    functionName: "accountingContextsOf",
+    chainId,
+    address: address && isAddressEqual3(address, zeroAddress3) ? void 0 : address
+  });
+  return /* @__PURE__ */ jsx7(
+    JBTerminalContext.Provider,
+    {
+      value: {
+        address,
+        store: {
+          data: store,
+          isLoading: isStoreLoading
+        },
+        accountingContexts: {
+          data: accountingContexts,
+          isLoading: accountingContextsLoading
+        }
+      },
+      children
+    }
+  );
+};
+
+// src/contexts/JBTerminalContext/JBPrimaryNativeTerminalProvider.tsx
+import { jsx as jsx8 } from "react/jsx-runtime";
+function JBPrimaryNativeTerminalProvider({
+  children
+}) {
+  const { contracts } = useJBContractContext();
+  const terminalAddress = contracts?.primaryNativeTerminal?.data;
+  debug8("JBPrimaryNativeTerminalProvider", { terminalAddress });
+  if (!terminalAddress) return children;
+  return /* @__PURE__ */ jsx8(JBTerminalProvider, { address: terminalAddress, children });
+}
+
+// src/contexts/JBProjectProvider/JBProjectProvider.tsx
+import { jsx as jsx9 } from "react/jsx-runtime";
+var JBProjectContext = createContext7(void 0);
+var JBProjectProvider = ({
+  projectId,
+  chainId,
+  children,
+  ctxProps,
+  version,
+  bendystraw
+}) => {
+  return /* @__PURE__ */ jsx9(JBProjectContext.Provider, { value: { chainId, projectId, version, bendystraw }, children: /* @__PURE__ */ jsx9(JBChainProvider, { chainId, children: /* @__PURE__ */ jsx9(JBContractProvider, { projectId, version, ...ctxProps?.contract, children: /* @__PURE__ */ jsx9(JBRulesetProvider, { children: /* @__PURE__ */ jsx9(JBProjectMetadataProvider, { ...ctxProps?.metadata, children: /* @__PURE__ */ jsx9(JBCurrentDataHookProvider, { children: /* @__PURE__ */ jsx9(JBPrimaryNativeTerminalProvider, { children: /* @__PURE__ */ jsx9(JBTokenProvider, { ...ctxProps?.token, children }) }) }) }) }) }) }) });
+};
+function useJBProject() {
+  return useContext7(JBProjectContext);
+}
+function useBendystrawConfig() {
+  return useContext7(JBProjectContext)?.bendystraw;
+}
+
+// src/lib/bendystraw/useBendystrawQuery.ts
+function useBendystrawQuery(document, ...[variables, options]) {
+  const chainId = useJBChainId();
+  const config = useBendystrawConfig();
+  const url = chainId && config ? getBendystrawUrl(chainId, config) : void 0;
+  return useQuery3({
+    queryKey: [document.definitions[0].name.value, chainId, variables],
+    queryFn: async () => request(`${url}/graphql`, document, variables),
+    enabled: options?.enabled !== false && !!chainId && !!url,
+    refetchInterval: options?.pollInterval,
+    retry: 3,
+    retryDelay: (attemptIndex) => Math.min(1e3 * 2 ** attemptIndex, 3e4),
+    // Exponential backoff
+    staleTime: 3e4,
+    // Consider data stale after 30 seconds
+    gcTime: 5 * 60 * 1e3
+    // Keep in cache for 5 minutes
+  });
+}
+
+// src/hooks/suckers/useSuckers.ts
+import {
+  arbitrum as arbitrum2,
+  arbitrumSepolia,
+  base as base2,
+  baseSepolia,
+  mainnet as mainnet3,
+  optimism as optimism2,
+  optimismSepolia,
+  sepolia
+} from "viem/chains";
+import { useMemo as useMemo2 } from "react";
+var chainOrder = [
+  mainnet3.id,
+  base2.id,
+  optimism2.id,
+  arbitrum2.id,
+  sepolia.id,
+  baseSepolia.id,
+  optimismSepolia.id,
+  arbitrumSepolia.id
+];
+function useSuckers(args) {
+  const { enabled = true } = args ?? {};
+  const { projectId, version } = useJBContractContext();
+  const chainId = useJBChainId();
+  debug9("useSuckers::args", { projectId, chainId });
+  const { data, ...rest } = useBendystrawQuery(ProjectDocument, {
+    projectId: Number(projectId),
+    chainId: Number(chainId),
+    version,
+    staleTime: Infinity,
+    enabled: !!chainId && enabled
+  });
+  const pairs = useMemo2(
+    () => data?.project?.suckerGroup?.projects?.items.map((item) => ({
+      peerChainId: item.chainId,
+      projectId: BigInt(item.projectId)
+    }))?.sort((a, b) => {
+      const aChainId = chainOrder.indexOf(a.peerChainId);
+      const bChainId = chainOrder.indexOf(b.peerChainId);
+      if (aChainId === -1 || bChainId === -1) return 0;
+      return aChainId - bChainId;
+    }),
+    [data]
+  );
+  return { data: pairs, ...rest };
+}
+
+// src/hooks/token/useNativeTokenSurplus.ts
+import {
+  ETH_CURRENCY_ID,
+  jbMultiTerminalAbi as jbMultiTerminalAbi2,
+  jbMultiTerminalV5Abi,
+  NATIVE_TOKEN,
+  NATIVE_TOKEN_DECIMALS as NATIVE_TOKEN_DECIMALS2
+} from "@bananapus/nana-sdk-core";
+import { useReadContract as useReadContract6 } from "wagmi";
+function useNativeTokenSurplus({
+  chainId
+} = {}) {
+  const {
+    projectId,
+    version,
+    contracts: { primaryNativeTerminal }
+  } = useJBContractContext();
+  const _chainId = chainId ?? useJBChainId();
+  const v6Query = useReadContract6({
+    chainId: _chainId,
+    abi: jbMultiTerminalAbi2,
+    functionName: "currentSurplusOf",
+    address: primaryNativeTerminal.data ?? void 0,
+    args: [
+      projectId,
+      [NATIVE_TOKEN],
+      BigInt(NATIVE_TOKEN_DECIMALS2),
+      BigInt(ETH_CURRENCY_ID)
+    ],
+    query: { enabled: version === 6 }
+  });
+  const legacyQuery = useReadContract6({
+    chainId: _chainId,
+    abi: jbMultiTerminalV5Abi,
+    functionName: "currentSurplusOf",
+    address: primaryNativeTerminal.data ?? void 0,
+    args: [
+      projectId,
+      [
+        {
+          token: NATIVE_TOKEN,
+          decimals: NATIVE_TOKEN_DECIMALS2,
+          currency: ETH_CURRENCY_ID
+        }
+      ],
+      BigInt(NATIVE_TOKEN_DECIMALS2),
+      BigInt(ETH_CURRENCY_ID)
+    ],
+    query: { enabled: version !== 6 }
+  });
+  return version === 6 ? v6Query : legacyQuery;
+}
+
+// src/hooks/token/useSuckersNativeTokenSurplus.ts
+import {
+  ETH_CURRENCY_ID as ETH_CURRENCY_ID2,
+  getPrimaryNativeTerminal,
+  jbMultiTerminalAbi as jbMultiTerminalAbi3,
+  jbMultiTerminalV5Abi as jbMultiTerminalV5Abi2,
+  NATIVE_TOKEN as NATIVE_TOKEN2,
+  NATIVE_TOKEN_DECIMALS as NATIVE_TOKEN_DECIMALS3
+} from "@bananapus/nana-sdk-core";
+import { getContract } from "viem";
+import { useConfig } from "wagmi";
+import { useQuery as useQuery4 } from "wagmi/query";
+function useSuckersNativeTokenSurplus() {
+  const config = useConfig();
+  const chainId = useJBChainId();
+  const { projectId, version } = useJBContractContext();
+  const { data: pairs = [], isLoading, isError } = useSuckers();
+  const surplusQuery = useQuery4({
+    queryKey: [
+      "suckersNativeTokenSurplus",
+      projectId.toString(),
+      chainId?.toString(),
+      version,
+      pairs?.map((pair) => pair.peerChainId).join(",")
+    ],
+    queryFn: async () => {
+      if (!chainId) return null;
+      if (!pairs || pairs.length === 0) {
+        return [];
+      }
+      const surpluses = await Promise.all(
+        pairs.map(async (pair) => {
+          const { peerChainId, projectId: projectId2 } = pair;
+          const terminal = await getPrimaryNativeTerminal(
+            config,
+            peerChainId,
+            projectId2,
+            version
+          );
+          const surplus = version === 6 ? await getContract({
+            address: terminal,
+            abi: jbMultiTerminalAbi3,
+            client: config.getClient({ chainId: peerChainId })
+          }).read.currentSurplusOf([
+            projectId2,
+            [NATIVE_TOKEN2],
+            BigInt(NATIVE_TOKEN_DECIMALS3),
+            BigInt(ETH_CURRENCY_ID2)
+          ]) : await getContract({
+            address: terminal,
+            abi: jbMultiTerminalV5Abi2,
+            client: config.getClient({ chainId: peerChainId })
+          }).read.currentSurplusOf([
+            projectId2,
+            [
+              {
+                token: NATIVE_TOKEN2,
+                decimals: NATIVE_TOKEN_DECIMALS3,
+                currency: ETH_CURRENCY_ID2
+              }
+            ],
+            BigInt(NATIVE_TOKEN_DECIMALS3),
+            BigInt(ETH_CURRENCY_ID2)
+          ]);
+          return { surplus, chainId: peerChainId, projectId: projectId2 };
+        })
+      );
+      return surpluses;
+    }
+  });
+  return {
+    isLoading: surplusQuery.isLoading || isLoading,
+    isError: surplusQuery.isError || isError,
+    data: surplusQuery.data
+  };
+}
+
+// src/hooks/token/useSuckersCashOutQuote.ts
+import {
+  applyJbDaoCashOutFee,
+  ETH_CURRENCY_ID as ETH_CURRENCY_ID3,
+  getProjectTerminalStore,
+  jbTerminalStoreAbi,
+  jbTerminalStoreV5Abi,
+  NATIVE_TOKEN_DECIMALS as NATIVE_TOKEN_DECIMALS4
+} from "@bananapus/nana-sdk-core";
+import { getContract as getContract2 } from "viem";
+import { useConfig as useConfig2 } from "wagmi";
+import { useQuery as useQuery5 } from "wagmi/query";
+function useSuckersCashOutQuote(tokenAmountWei) {
+  const config = useConfig2();
+  const chainId = useJBChainId();
+  const { projectId, version } = useJBContractContext();
+  const { data: pairs = [], isLoading, error } = useSuckers();
+  const suckersQuote = useQuery5({
+    queryKey: [
+      "suckersTokenRedemptionQuote",
+      projectId.toString(),
+      chainId?.toString(),
+      version,
+      tokenAmountWei.toString(),
+      pairs.map((pair) => pair.peerChainId).join(",")
+    ],
+    enabled: Boolean(!isLoading && chainId),
+    queryFn: async () => {
+      if (!chainId) return null;
+      const quotes = await Promise.all(
+        pairs.map(async ({ peerChainId, projectId: projectId2 }) => {
+          return getTokenRedemptionQuote(
+            config,
+            peerChainId,
+            projectId2,
+            tokenAmountWei,
+            version
+          );
+        }) ?? []
+      );
+      return quotes.reduce((acc, quote) => acc + quote, 0n);
+    }
+  });
+  const netTotal = applyJbDaoCashOutFee(suckersQuote.data ?? 0n);
+  return {
+    data: netTotal,
+    isLoading: suckersQuote.isLoading || isLoading,
+    errors: [error, suckersQuote.error].filter(Boolean)
+  };
+}
+async function getTokenRedemptionQuote(config, chainId, projectId, tokenAmountWei, version) {
+  const contract = getContract2({
+    address: getProjectTerminalStore(chainId, version),
+    abi: version === 6 ? jbTerminalStoreAbi : jbTerminalStoreV5Abi,
+    client: config.getClient({ chainId })
+  });
+  return await contract.read.currentReclaimableSurplusOf([
+    projectId,
+    tokenAmountWei,
+    [],
+    [],
+    BigInt(NATIVE_TOKEN_DECIMALS4),
+    BigInt(ETH_CURRENCY_ID3)
+  ]);
+}
+
+// src/hooks/token/useTokenCashOutQuoteEth.ts
+import {
+  ETH_CURRENCY_ID as ETH_CURRENCY_ID4,
+  NATIVE_TOKEN_DECIMALS as NATIVE_TOKEN_DECIMALS5,
+  applyJbDaoCashOutFee as applyJbDaoCashOutFee2,
+  jbTerminalStoreAbi as jbTerminalStoreAbi2,
+  jbTerminalStoreV5Abi as jbTerminalStoreV5Abi2
+} from "@bananapus/nana-sdk-core";
+import { useReadContract as useReadContract7 } from "wagmi";
+function useTokenCashOutQuoteEth(tokenAmountWei, { chainId }) {
+  const { projectId, version } = useJBContractContext();
+  const { store } = useJBTerminalContext();
+  const jbChainId = useJBChainId();
+  const _chainId = chainId ?? jbChainId;
+  return useReadContract7({
+    abi: version === 6 ? jbTerminalStoreAbi2 : jbTerminalStoreV5Abi2,
+    functionName: "currentReclaimableSurplusOf",
+    chainId: _chainId,
+    address: store.data ?? void 0,
+    args: tokenAmountWei ? [projectId, tokenAmountWei, [], [], BigInt(NATIVE_TOKEN_DECIMALS5), BigInt(ETH_CURRENCY_ID4)] : void 0,
+    query: {
+      select(data) {
+        return applyJbDaoCashOutFee2(data);
+      }
+    }
+  });
+}
+
+// src/hooks/token/useSuckersTokenCashOutValue.ts
+import { ONE_JB_TOKEN } from "@bananapus/nana-sdk-core";
+import { formatEther } from "viem";
+
+// src/hooks/useEtherPrice.ts
+import { useQuery as useQuery6 } from "wagmi/query";
+var PRICE_REFRESH_INTERVAL = 60 * 1e3 * 5;
+function useEtherPrice() {
+  return useQuery6({
+    queryKey: ["juice-sdk", "etherPrice"],
+    queryFn: async () => {
+      return fetch("https://juicebox.money/api/juicebox/prices/ethusd").then((res) => res.json()).then((data) => data.price);
+    },
+    staleTime: PRICE_REFRESH_INTERVAL
+  });
+}
+
+// src/hooks/token/useSuckersTokenCashOutValue.ts
+function useSuckersTokenCashOutValue({ targetCurrency }) {
+  const { data: ethPrice, isLoading: isEthLoading } = useEtherPrice();
+  const { data: quote, isLoading: isQuoteLoading, errors } = useSuckersCashOutQuote(ONE_JB_TOKEN);
+  const loading = isQuoteLoading || isEthLoading;
+  if (loading) {
+    return { loading: true, data: void 0 };
+  }
+  const quoteEth = parseFloat(formatEther(quote ?? 0n));
+  const data = targetCurrency === "eth" ? quoteEth : quoteEth * (ethPrice ?? 0);
+  return {
+    loading,
+    data,
+    errors
+  };
+}
+
+// src/hooks/token/useSuckersUserTokenBalance.ts
+import { JBCoreContracts as JBCoreContracts2, JBProjectToken as JBProjectToken2, jbTokensAbi as jbTokensAbi2 } from "@bananapus/nana-sdk-core";
+import { getContract as getContract3 } from "viem";
+import { useAccount as useAccount2, useConfig as useConfig3, useReadContract as useReadContract8 } from "wagmi";
+import { useQuery as useQuery7 } from "wagmi/query";
+function useSuckersUserTokenBalance() {
+  const config = useConfig3();
+  const chainId = useJBChainId();
+  const { projectId, contractAddress } = useJBContractContext();
+  const { address: userAddress } = useAccount2();
+  const currentChainQuery = useReadContract8({
+    abi: jbTokensAbi2,
+    functionName: "totalBalanceOf",
+    address: contractAddress(JBCoreContracts2.JBTokens),
+    chainId,
+    args: userAddress ? [userAddress, projectId] : void 0,
+    query: {
+      select(data) {
+        return new JBProjectToken2(data);
+      }
+    }
+  });
+  const { data: pairs = [], isLoading, isError } = useSuckers();
+  const balanceQuery = useQuery7({
+    queryKey: [
+      "suckersUserTokenBalance",
+      projectId.toString(),
+      chainId?.toString(),
+      currentChainQuery.data?.value.toString(),
+      pairs?.map((pair) => pair.peerChainId).join(",")
+    ],
+    queryFn: async () => {
+      if (!chainId || !userAddress) return null;
+      const currentChain = {
+        balance: currentChainQuery.data ?? new JBProjectToken2(0n),
+        chainId,
+        projectId
+      };
+      if (!pairs || pairs.length === 0) {
+        return [currentChain];
+      }
+      const balances = await Promise.all(
+        pairs.map(async (pair) => {
+          const { peerChainId, projectId: projectId2 } = pair;
+          const contract = getContract3({
+            address: contractAddress(JBCoreContracts2.JBTokens, peerChainId),
+            abi: jbTokensAbi2,
+            client: config.getClient({ chainId: peerChainId })
+          });
+          const balance = await contract.read.totalBalanceOf([userAddress, projectId2]);
+          return {
+            balance: new JBProjectToken2(balance),
+            chainId: peerChainId,
+            projectId: projectId2
+          };
+        })
+      );
+      if (!balances.some((balance) => balance.chainId === currentChain.chainId)) {
+        balances.push(currentChain);
+      }
+      return balances;
+    }
+  });
+  return {
+    isLoading: balanceQuery.isLoading || isLoading,
+    isError: balanceQuery.isError || isError,
+    data: balanceQuery.data
+  };
+}
+
+// src/hooks/token/useSuckersNativeTokenBalance.ts
+import {
+  getPrimaryNativeTerminal as getPrimaryNativeTerminal2,
+  getProjectTerminalStore as getProjectTerminalStore2,
+  jbTerminalStoreAbi as jbTerminalStoreAbi3,
+  NATIVE_TOKEN as NATIVE_TOKEN3
+} from "@bananapus/nana-sdk-core";
+import { getContract as getContract4 } from "viem";
+import { useConfig as useConfig4 } from "wagmi";
+import { useQuery as useQuery8 } from "wagmi/query";
+function useSuckersNativeTokenBalance() {
+  const config = useConfig4();
+  const chainId = useJBChainId();
+  const { projectId, version } = useJBContractContext();
+  const { data: pairs = [], isLoading, isError } = useSuckers();
+  const balanceQuery = useQuery8({
+    queryKey: [
+      "suckersNativeTokenBalance",
+      projectId.toString(),
+      chainId?.toString(),
+      pairs.map((pair) => pair.peerChainId).join(",")
+    ],
+    queryFn: async () => {
+      if (!chainId) return null;
+      if (!pairs || pairs.length === 0) return [];
+      const balances = await Promise.all(
+        pairs.map(async (pair) => {
+          const { peerChainId, projectId: projectId2 } = pair;
+          const terminal = await getPrimaryNativeTerminal2(config, peerChainId, projectId2, version);
+          const contract = getContract4({
+            address: getProjectTerminalStore2(peerChainId, version),
+            abi: jbTerminalStoreAbi3,
+            client: config.getClient({ chainId: peerChainId })
+          });
+          const balance = await contract.read.balanceOf([terminal, projectId2, NATIVE_TOKEN3]);
+          return { balance, chainId: peerChainId, projectId: projectId2 };
+        })
+      );
+      return balances;
+    }
+  });
+  return {
+    isLoading: balanceQuery.isLoading || isLoading,
+    isError: balanceQuery.isError || isError,
+    data: balanceQuery.data
+  };
+}
+
+// src/hooks/ruleset/useJBRuleset.ts
+import {
+  CashOutTaxRate as CashOutTaxRate2,
+  jbControllerAbi as jbControllerAbi3,
+  ReservedPercent as ReservedPercent2,
+  RulesetWeight as RulesetWeight2,
+  WeightCutPercent as WeightCutPercent2
+} from "@bananapus/nana-sdk-core";
+import { useReadContract as useReadContract9 } from "wagmi";
+function useJBRuleset({
+  projectId,
+  chainId
+}) {
+  const { contracts, version } = useJBContractContext();
+  const query = useReadContract9({
+    chainId,
+    abi: jbControllerAbi3,
+    functionName: "currentRulesetOf",
+    address: contracts?.controller?.data ?? void 0,
+    args: projectId ? [projectId] : void 0,
+    query: {
+      enabled: !!projectId && !!contracts?.controller?.data,
+      select([ruleset, rulesetMetadata]) {
+        return {
+          data: {
+            ...ruleset,
+            weight: new RulesetWeight2(ruleset.weight),
+            weightCutPercent: new WeightCutPercent2(ruleset.weightCutPercent)
+          },
+          metadata: {
+            ...rulesetMetadata,
+            cashOutTaxRate: new CashOutTaxRate2(rulesetMetadata.cashOutTaxRate),
+            reservedPercent: new ReservedPercent2(rulesetMetadata.reservedPercent),
+            // v4/v5 store the INVERSE flag (`useTotalSurplusForCashOuts`) in this slot;
+            // normalize to the v6 field's semantics.
+            scopeCashOutsToLocalBalances: version === 6 ? rulesetMetadata.scopeCashOutsToLocalBalances : !rulesetMetadata.scopeCashOutsToLocalBalances
+          }
+        };
+      }
+    }
+  });
+  const { resolvedDataHook } = useResolveDataHook({
+    dataHookAddress: query.data?.metadata?.dataHook,
+    projectId,
+    chainId,
+    rulesetId: BigInt(query.data?.data?.id ?? 0)
+  });
+  return {
+    ruleset: query.data?.data,
+    rulesetMetadata: query.data?.metadata && {
+      ...query.data.metadata,
+      dataHook: resolvedDataHook
+    },
+    ...query
+  };
+}
+
+// src/hooks/ruleset/useJBUpcomingRuleset.ts
+import {
+  CashOutTaxRate as CashOutTaxRate3,
+  jbControllerAbi as jbControllerAbi4,
+  ReservedPercent as ReservedPercent3,
+  RulesetWeight as RulesetWeight3,
+  WeightCutPercent as WeightCutPercent3
+} from "@bananapus/nana-sdk-core";
+import { useReadContract as useReadContract10 } from "wagmi";
+function useJBUpcomingRuleset({
+  projectId,
+  chainId
+}) {
+  const { contracts, version } = useJBContractContext();
+  const { data, isLoading } = useReadContract10({
+    abi: jbControllerAbi4,
+    functionName: "upcomingRulesetOf",
+    address: contracts.controller?.data ?? void 0,
+    args: projectId ? [projectId] : void 0,
+    chainId
+  });
+  const _latestUpcomingRuleset = data?.[0];
+  const _latestUpcomingRulesetMetadata = data?.[1];
+  const { resolvedDataHook } = useResolveDataHook({
+    dataHookAddress: _latestUpcomingRulesetMetadata?.dataHook,
+    projectId,
+    chainId,
+    rulesetId: BigInt(_latestUpcomingRuleset?.id ?? 0)
+  });
+  const upcomingWeight = new RulesetWeight3(_latestUpcomingRuleset?.weight ?? 0n);
+  const upcomingWeightCutPercent = new WeightCutPercent3(
+    _latestUpcomingRuleset?.weightCutPercent ?? 0
+  );
+  const latestUpcomingRuleset = _latestUpcomingRuleset ? {
+    ..._latestUpcomingRuleset,
+    weight: upcomingWeight,
+    weightCutPercent: upcomingWeightCutPercent
+  } : void 0;
+  const upcomingReservedPercent = new ReservedPercent3(
+    _latestUpcomingRulesetMetadata?.reservedPercent ?? 0
+  );
+  const upcomingCashOutTaxRate = new CashOutTaxRate3(
+    _latestUpcomingRulesetMetadata?.cashOutTaxRate ?? 0
+  );
+  const latestUpcomingRulesetMetadata = _latestUpcomingRulesetMetadata ? {
+    ..._latestUpcomingRulesetMetadata,
+    reservedPercent: upcomingReservedPercent,
+    cashOutTaxRate: upcomingCashOutTaxRate,
+    // v4/v5 store the INVERSE flag (`useTotalSurplusForCashOuts`) in this slot;
+    // normalize to the v6 field's semantics.
+    scopeCashOutsToLocalBalances: version === 6 ? _latestUpcomingRulesetMetadata.scopeCashOutsToLocalBalances : !_latestUpcomingRulesetMetadata.scopeCashOutsToLocalBalances,
+    dataHook: resolvedDataHook
+  } : void 0;
+  return {
+    ruleset: latestUpcomingRuleset,
+    rulesetMetadata: latestUpcomingRulesetMetadata,
+    isLoading
+  };
+}
+
+// src/contexts/JBContractContext/JBContractContext.tsx
+import { useReadContract as useReadContract11 } from "wagmi";
+import { jsx as jsx10 } from "react/jsx-runtime";
+var JBContractContext = createContext8({
+  /**
+   * The project id of the Juicebox project.
+   */
+  projectId: 0n,
+  version: 5,
+  /**
+   * The addresses of the contracts for the project.
+   */
+  contracts: {
+    primaryNativeTerminal: AsyncDataNone,
+    controller: AsyncDataNone,
+    fundAccessLimits: AsyncDataNone,
+    rulesets: AsyncDataNone,
+    tokens: AsyncDataNone,
+    splits: AsyncDataNone
+  },
+  contractAddress: () => zeroAddress4
+});
+function useJBContractContext() {
+  return useContext8(JBContractContext);
+}
+var DynamicContract = /* @__PURE__ */ ((DynamicContract2) => {
+  DynamicContract2[DynamicContract2["Controller"] = 0] = "Controller";
+  DynamicContract2[DynamicContract2["PrimaryNativePaymentTerminal"] = 1] = "PrimaryNativePaymentTerminal";
+  DynamicContract2[DynamicContract2["FundAccessLimits"] = 2] = "FundAccessLimits";
+  DynamicContract2[DynamicContract2["Tokens"] = 3] = "Tokens";
+  DynamicContract2[DynamicContract2["Splits"] = 4] = "Splits";
+  DynamicContract2[DynamicContract2["Rulesets"] = 5] = "Rulesets";
+  return DynamicContract2;
+})(DynamicContract || {});
+function useJBProjectId(chainId) {
+  const currentChainId = useJBChainId();
+  const { projectId: currentProjectId, version } = useJBContractContext();
+  const { data: suckers } = useSuckers({ enabled: !!chainId });
+  if (!chainId || currentChainId === chainId || !suckers) {
+    return { projectId: currentProjectId, chainId: currentChainId, version };
+  }
+  const projectId = suckers.find((suckerPair) => suckerPair.peerChainId === chainId)?.projectId;
+  return { projectId, chainId, version };
+}
+var JBContractProvider = ({
+  projectId,
+  include,
+  children,
+  version
+}) => {
+  const chainId = useJBChainId();
+  const enabled = useCallback(
+    (selector) => {
+      if (typeof include === "undefined") return true;
+      return include.some((c) => selector.includes(c));
+    },
+    [include]
+  );
+  const jbDirectoryAddress = chainId ? jbContractAddress2[version][JBCoreContracts3.JBDirectory][chainId] : void 0;
+  const primaryNativeTerminalEth = useReadContract11({
+    address: jbDirectoryAddress,
+    abi: jbDirectoryAbi,
+    functionName: "primaryTerminalOf",
+    chainId,
+    args: enabled([1 /* PrimaryNativePaymentTerminal */]) ? [projectId, NATIVE_TOKEN4] : void 0
+  });
+  const primaryNativeTerminalUsdc = useReadContract11({
+    address: jbDirectoryAddress,
+    abi: jbDirectoryAbi,
+    functionName: "primaryTerminalOf",
+    chainId,
+    args: enabled([1 /* PrimaryNativePaymentTerminal */]) ? [projectId, chainId ? USDC_ADDRESSES[chainId] : zeroAddress4] : void 0
+  });
+  const primaryNativeTerminal = useMemo3(() => {
+    return primaryNativeTerminalEth.data !== zeroAddress4 ? primaryNativeTerminalEth : primaryNativeTerminalUsdc;
+  }, [primaryNativeTerminalEth, primaryNativeTerminalUsdc]);
+  const controller = useReadContract11({
+    chainId,
+    address: jbDirectoryAddress,
+    abi: jbDirectoryAbi,
+    functionName: "controllerOf",
+    args: [projectId],
+    query: {
+      enabled: enabled([0 /* Controller */]),
+      staleTime: Infinity
+    }
+  });
+  const controllerAddress = useMemo3(() => controller.data, [controller.data]);
+  const hasController = useMemo3(() => {
+    return controllerAddress && !isAddressEqual4(controllerAddress, zeroAddress4);
+  }, [controllerAddress]);
+  const normalizedControllerAddress = useMemo3(() => {
+    return hasController ? controllerAddress : zeroAddress4;
+  }, [controllerAddress, hasController]);
+  const fundAccessLimits = useReadContract11({
+    chainId,
+    address: normalizedControllerAddress,
+    abi: jbControllerAbi5,
+    functionName: "FUND_ACCESS_LIMITS",
+    query: {
+      enabled: enabled([0 /* Controller */, 2 /* FundAccessLimits */]),
+      staleTime: Infinity
+    }
+  });
+  const rulesets = useReadContract11({
+    chainId,
+    address: normalizedControllerAddress,
+    abi: jbControllerAbi5,
+    functionName: "RULESETS",
+    query: {
+      enabled: enabled([0 /* Controller */, 5 /* Rulesets */]),
+      staleTime: Infinity
+    }
+  });
+  const tokens = useReadContract11({
+    chainId,
+    address: normalizedControllerAddress,
+    abi: jbControllerAbi5,
+    functionName: "TOKENS",
+    query: {
+      enabled: enabled([0 /* Controller */, 3 /* Tokens */]),
+      staleTime: Infinity
+    }
+  });
+  const splits = useReadContract11({
+    chainId,
+    address: normalizedControllerAddress,
+    abi: jbControllerAbi5,
+    functionName: "SPLITS",
+    query: {
+      enabled: enabled([0 /* Controller */, 4 /* Splits */]),
+      staleTime: Infinity
+    }
+  });
+  const contractAddress = useCallback(
+    (contract, _chainId) => {
+      return getJBContractAddress2(contract, version, _chainId || chainId);
+    },
+    [version, chainId]
+  );
+  debug10("JBContractContext", {
+    projectId,
+    contracts: {
+      controller,
+      fundAccessLimits,
+      primaryNativeTerminal,
+      rulesets,
+      tokens,
+      splits
+    }
+  });
+  return /* @__PURE__ */ jsx10(
+    JBContractContext.Provider,
+    {
+      value: {
+        version,
+        projectId,
+        contracts: {
+          controller,
+          fundAccessLimits,
+          primaryNativeTerminal,
+          rulesets,
+          tokens,
+          splits
+        },
+        contractAddress
+      },
+      children
+    }
+  );
+};
+
+// src/lib/relayr/constants.ts
+var API = "https://api.relayr.ba5ed.com";
+var DASHBOARD = "https://relayr.ba5ed.com";
+
+// src/lib/relayr/hooks/useRequestRelayrQuote.ts
+import { jbContractAddress as jbContractAddress3 } from "@bananapus/nana-sdk-core";
+import { useMutation } from "wagmi/query";
+function useRequestRelayrQuote() {
+  const { version: contextVersion } = useJBContractContext();
+  return useMutation({
+    mutationFn: async (args) => {
+      const transactions = args.map((ct) => {
+        return {
+          chain: ct.chain,
+          data: ct.data,
+          target: jbContractAddress3[ct.version ?? contextVersion]["ERC2771Forwarder"][ct.chain],
+          value: ct.value
+        };
+      });
+      const response = await fetch(`${API}/v1/bundle/prepaid`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          transactions,
+          virtual_nonce_mode: "Disabled"
+        })
+      });
+      if (!response.ok) {
+        console.error("Relayr ERROR:: ", response);
+        const errorMessage = await response.text();
+        throw new Error(errorMessage);
+      }
+      return await response.json();
+    }
+  });
+}
+
+// src/lib/relayr/hooks/useSignErc2771ForwardRequest.ts
+import { erc2771ForwarderAbi, jbContractAddress as jbContractAddress4 } from "@bananapus/nana-sdk-core";
+import { encodeFunctionData, getContract as getContract5 } from "viem";
+import { useAccount as useAccount3, useConfig as useConfig5, useSignTypedData, useSwitchChain } from "wagmi";
+function useSignErc2771ForwardRequest() {
+  const { switchChainAsync } = useSwitchChain();
+  const { address } = useAccount3();
+  const config = useConfig5();
+  const { signTypedData } = useSignTypedData();
+  const { version: contextVersion } = useJBContractContext();
+  async function sign(messageData, chainId, version) {
+    await switchChainAsync({ chainId });
+    return new Promise(async (resolve, reject) => {
+      if (!address) return;
+      const verifyingContract = jbContractAddress4[version ?? contextVersion]["ERC2771Forwarder"][chainId];
+      const deadline = Number(((Date.now() + 3600 * 48 * 1e3) / 1e3).toFixed(0));
+      const contract = getContract5({
+        address: verifyingContract,
+        abi: erc2771ForwarderAbi,
+        client: config.getClient({ chainId })
+      });
+      const nonce = await contract.read.nonces([address]);
+      signTypedData(
+        {
+          domain: {
+            name: "Juicebox",
+            chainId,
+            verifyingContract,
+            version: "1"
+          },
+          primaryType: "ForwardRequest",
+          types: {
+            ForwardRequest: [
+              {
+                name: "from",
+                type: "address"
+              },
+              {
+                name: "to",
+                type: "address"
+              },
+              {
+                name: "value",
+                type: "uint256"
+              },
+              {
+                name: "gas",
+                type: "uint256"
+              },
+              {
+                name: "nonce",
+                type: "uint256"
+              },
+              {
+                name: "deadline",
+                type: "uint48"
+              },
+              {
+                name: "data",
+                type: "bytes"
+              }
+            ]
+          },
+          message: { ...messageData, deadline, nonce }
+        },
+        {
+          onSuccess: (signature) => {
+            const executeFnEncodedData = encodeFunctionData({
+              abi: erc2771ForwarderAbi,
+              // ABI of the contract
+              functionName: "execute",
+              args: [
+                {
+                  ...messageData,
+                  deadline,
+                  signature
+                }
+              ]
+            });
+            resolve(executeFnEncodedData);
+          },
+          onError: (e) => {
+            reject(e);
+          }
+        }
+      );
+    });
+  }
+  return {
+    sign
+  };
+}
+
+// src/lib/relayr/hooks/useGetRelayrTxQuote.ts
+function useGetRelayrTxQuote() {
+  const requestRelayrQuote = useRequestRelayrQuote();
+  const { sign } = useSignErc2771ForwardRequest();
+  async function getRelayrTxQuote(data) {
+    if (!data) return;
+    const txDataRequest = [];
+    for (const d of data) {
+      const signedData = await sign(d.data, d.chainId, d.version);
+      txDataRequest.push({
+        chain: d.chainId,
+        data: signedData,
+        // The forwarder needs the forward request's value passed along with the execute call.
+        value: d.data.value.toString(),
+        version: d.version
+      });
+    }
+    return await requestRelayrQuote.mutateAsync(txDataRequest);
+  }
+  return {
+    getRelayrTxQuote,
+    ...requestRelayrQuote
+  };
+}
+
+// src/lib/relayr/hooks/useGetRelayrTxBundle.ts
+import { useMemo as useMemo4, useState } from "react";
+import { useQuery as useQuery9 } from "wagmi/query";
+var POLL_INTERVAL = 2e3;
+var fetchTxBundle = async (uuid) => {
+  if (!uuid) {
+    throw new Error("No UUID provided");
+  }
+  const response = await fetch(`${API}/v1/bundle/${uuid}`);
+  if (!response.ok) {
+    const errorMessage = await response.text();
+    throw new Error(errorMessage);
+  }
+  return response.json();
+};
+function useGetRelayrTxBundle() {
+  const [uuid, setUuid] = useState();
+  const getRelayrTxBundle = useQuery9({
+    queryKey: ["txBundle", uuid],
+    queryFn: () => fetchTxBundle(uuid),
+    enabled: !!uuid,
+    refetchInterval: (query) => query.state.data?.transactions?.every((tx) => tx?.status.state === "Success") ? false : POLL_INTERVAL
+  });
+  const startPolling = (bundleUuid) => {
+    setUuid(bundleUuid);
+    getRelayrTxBundle.refetch();
+  };
+  const isComplete = useMemo4(
+    () => getRelayrTxBundle.data?.transactions?.every(
+      (tx) => tx?.status.state === "Success"
+    ),
+    [getRelayrTxBundle.data]
+  );
+  return {
+    startPolling,
+    isComplete,
+    uuid,
+    response: getRelayrTxBundle.data,
+    isPolling: getRelayrTxBundle.isFetching,
+    error: getRelayrTxBundle.error
+  };
+}
+
+// src/lib/relayr/hooks/useSendRelayrTx.ts
+import { useCallback as useCallback2 } from "react";
+import { useChainId, useSwitchChain as useSwitchChain2, useSendTransaction } from "wagmi";
+function useSendRelayrTx() {
+  const chainId = useChainId();
+  const { switchChainAsync } = useSwitchChain2();
+  const _sendTransaction = useSendTransaction();
+  const sendRelayrTx = useCallback2(
+    async (chainPayment) => {
+      try {
+        if (chainId !== chainPayment.chain) {
+          try {
+            await switchChainAsync({ chainId: chainPayment.chain });
+          } catch (e) {
+            console.error(e);
+            throw new Error("Failed to switch to correct chain");
+          }
+        }
+        const tx = await _sendTransaction.sendTransactionAsync({
+          to: chainPayment.target,
+          value: BigInt(chainPayment.amount),
+          data: chainPayment.calldata
+        });
+        return tx;
+      } catch (error) {
+        throw error;
+      }
+    },
+    [_sendTransaction.sendTransactionAsync, chainId, switchChainAsync]
+  );
+  return {
+    sendRelayrTx,
+    isPending: _sendTransaction.isPending,
+    error: _sendTransaction.error,
+    isSuccess: _sendTransaction.isSuccess,
+    data: _sendTransaction.data
+  };
+}
+export {
+  API,
+  DASHBOARD,
+  DynamicContract,
+  JBChainContext,
+  JBChainProvider,
+  JBContractContext,
+  JBContractProvider,
+  JBDataHookContext,
+  JBDataHookProvider,
+  JBProjectMetadataContext,
+  JBProjectMetadataProvider,
+  JBProjectProvider,
+  JBRulesetContext,
+  JBRulesetProvider,
+  JBTerminalContext,
+  JBTerminalProvider,
+  JBTokenContext,
+  JBTokenProvider,
+  NativeTokenValue,
+  getBendystrawUrl,
+  useBendystrawQuery,
+  useChain,
+  useEtherPrice,
+  useFind721DataHook,
+  useGetRelayrTxBundle,
+  useGetRelayrTxQuote,
+  useJBChainId,
+  useJBContractContext,
+  useJBDataHookContext,
+  useJBProject,
+  useJBProjectId,
+  useJBProjectMetadataContext,
+  useJBRuleset,
+  useJBRulesetContext,
+  useJBRulesetMetadata,
+  useJBTerminalContext,
+  useJBTokenContext,
+  useJBUpcomingRuleset,
+  useNativeTokenSurplus,
+  useNativeTokenSymbol,
+  usePreparePayMetadata,
+  useProjectMetadata,
+  useResolveDataHook,
+  useSendRelayrTx,
+  useSuckers,
+  useSuckersCashOutQuote,
+  useSuckersNativeTokenBalance,
+  useSuckersNativeTokenSurplus,
+  useSuckersTokenCashOutValue,
+  useSuckersUserTokenBalance,
+  useTokenCashOutQuoteEth
+};
+//# sourceMappingURL=index.js.map