Juicebox Protocol V5

// Get project owner
address owner = JBProjects.ownerOf(projectId);

// Get project metadata URI
string memory uri = JBController.uriOf(projectId);

function launchProjectFor(
    address owner,
    string calldata projectUri,
    JBRulesetConfig[] calldata rulesetConfigurations,
    JBTerminalConfig[] calldata terminalConfigurations,
    string calldata memo
) external returns (uint256 projectId);

// Via REVDeployer
function deployFor(
    uint256 revnetId,
    REVConfig calldata configuration,
    JBTerminalConfig[] calldata terminalConfigurations,
    REVBuybackHookConfig calldata buybackHookConfiguration,
    REVSuckerDeploymentConfig calldata suckerDeploymentConfiguration,
    REVCroptopAllowedPost[] calldata allowedPosts,
    bytes calldata extraHookMetadata,
    JBPayHookSpecification[] memory otherPayHooksSpecifications
) external returns (uint256, address);

// Get total token balance (credits + ERC-20)
uint256 balance = JBTokens.totalBalanceOf(holder, projectId);

// Get only credit balance
uint256 credits = JBTokens.creditBalanceOf(holder, projectId);

// Get project's ERC-20 token
IJBToken token = JBTokens.tokenOf(projectId);

// Claim credits as ERC-20
JBTokens.claimTokensFor(holder, projectId, amount, beneficiary);

// Deploy ERC-20 for project
IJBToken token = JBController.deployERC20For(projectId, "Name", "SYMBOL", salt);

const rulesetConfig = {
  mustStartAtOrAfter: 0,
  duration: 0,                    // Infinite ruleset
  weight: 1_000_000_000_000_000_000_000_000, // 1M tokens per ETH
  weightCutPercent: 0,
  approvalHook: ethers.ZeroAddress,
  metadata: {
    reservedPercent: 5_000,       // 50%
    cashOutTaxRate: 0,
    baseCurrency: 1,              // ETH
    pausePay: false,
    pauseCreditTransfers: false,
    allowOwnerMinting: false,
    allowTerminalMigration: false,
    allowSetTerminals: false,
    allowSetController: false,
    allowAddAccountingContext: false,
    allowAddPriceFeed: false,
    ownerMustSendPayouts: false,
    holdFees: false,
    useTotalSurplusForCashOuts: false,
    useDataHookForPay: false,
    useDataHookForCashOut: false,
    dataHook: ethers.ZeroAddress,
    metadata: 0
  },
  splitGroups: [
    {
      groupId: 1, // Payouts
      splits: [
        {
          preferAddToBalance: false,
          percent: 500_000_000,   // 50%
          projectId: 0,
          beneficiary: "0x...",
          lockedUntil: 0,
          hook: ethers.ZeroAddress
        }
      ]
    }
  ],
  fundAccessLimitGroups: [
    {
      terminal: JBMultiTerminal.address,
      token: ethers.ZeroAddress, // Native token
      payoutLimits: [
        { amount: ethers.parseEther("10"), currency: 1 }
      ],
      surplusAllowances: []
    }
  ]
};

const terminalConfig = {
  terminal: JBMultiTerminal.address,
  accountingContextsToAccept: [
    {
      token: ethers.ZeroAddress, // ETH
      decimals: 18,
      currency: 61166           // Native token currency
    }
  ]
};

import { JBProjectProvider, useJBProjectMetadata, useJBRuleset, useJBTokenContext, usePay, useCashOut } from "juice-sdk-react";

function App() {
  return (
    <JBProjectProvider projectId={1n} ctxProps={{ metadata: { ipfsGatewayHostname: "..." }}}>
      <ProjectComponent />
    </JBProjectProvider>
  );
}

function ProjectComponent() {
  // Read Hooks
  const { data: metadata } = useJBProjectMetadata();
  const { ruleset, rulesetMetadata } = useJBRuleset();
  const { token } = useJBTokenContext();

  // Write Hooks
  const { write: pay } = usePay();
  const { write: cashOut } = useCashOut();

  return <div>...</div>;
}

// Send payouts (up to payout limit)
function sendPayoutsOf(
    uint256 projectId,
    address token,
    uint256 amount,
    uint256 currency,
    uint256 minTokensPaidOut
) external returns (uint256 netLeftoverPayoutAmount);

// Use surplus allowance (owner only)
function useAllowanceOf(
    uint256 projectId,
    address token,
    uint256 amount,
    uint256 currency,
    uint256 minTokensPaidOut,
    address payable beneficiary,
    address payable feeBeneficiary,
    string calldata memo
) external returns (uint256 netAmountPaidOut);

// Distribute reserved tokens
JBController.sendReservedTokensToSplitsOf(projectId);

interface IJBRulesetDataHook {
    function beforePayRecordedWith(JBBeforePayRecordedContext calldata context)
        external view returns (uint256 weight, JBPayHookSpecification[] memory hookSpecifications);

    function beforeCashOutRecordedWith(JBBeforeCashOutRecordedContext calldata context)
        external view returns (uint256 cashOutTaxRate, uint256 cashOutCount, uint256 totalSupply, JBCashOutHookSpecification[] memory hookSpecifications);
}

interface IJBPayHook {
    function afterPayRecordedWith(JBAfterPayRecordedContext calldata context) external payable;
}

interface IJBCashOutHook {
    function afterCashOutRecordedWith(JBAfterCashOutRecordedContext calldata context) external payable;
}

interface IJBSplitHook {
    function processSplitWith(JBSplitHookContext calldata context) external payable;
}

interface IJBRulesetApprovalHook {
    function approvalStatusOf(uint256 projectId, uint256 rulesetId, uint256 start)
        external view returns (JBApprovalStatus);
}

function cashOutTokensOf(
    address holder,
    uint256 projectId,
    uint256 cashOutCount,    // Tokens to burn
    address tokenToReclaim,  // Token to receive (ETH, USDC, etc.)
    uint256 minTokensReclaimed,
    address payable beneficiary,
    bytes calldata metadata
) external returns (uint256 reclaimAmount);

function launchProjectFor(
    address owner,
    string calldata projectUri,
    JBRulesetConfig[] calldata rulesetConfigurations,
    JBTerminalConfig[] calldata terminalConfigurations,
    string calldata memo,
    REVSuckerDeploymentConfig calldata suckerDeploymentConfiguration
) external returns (uint256 projectId, address[] memory suckers);