Payments & Revenue Distribution

pnpm add @provenancekit/payments

import { calculateDistribution } from "@provenancekit/extensions";

const contributions = [
  { entityId: "user:alice", weight: 60 },
  { entityId: "user:bob", weight: 30 },
  { entityId: "user:carol", weight: 10 },
];

const distribution = calculateDistribution(contributions, 10_000); // basis points
// { "user:alice": 6000, "user:bob": 3000, "user:carol": 1000 }
// Sum always equals 10_000 — no dust, no rounding errors

import { ProvenanceKit } from "@provenancekit/sdk";
import { calculateDistributionFromBundle } from "@provenancekit/extensions";

const pk = new ProvenanceKit({ apiKey: "pk_live_..." });
const bundle = await pk.getBundle(resourceCid);

const distribution = calculateDistributionFromBundle(bundle, 10_000);

async function resolveWallets(distribution: Record<string, number>) {
  const resolved: Array<{ address: string; share: number }> = [];
  for (const [entityId, share] of Object.entries(distribution)) {
    const entity = await db.getEntity(entityId);
    if (entity?.wallet) {
      resolved.push({ address: entity.wallet, share });
    }
  }
  return resolved;
}

import { SplitsAdapter } from "@provenancekit/payments";
import { createWalletClient, http } from "viem";
import { base } from "viem/chains";

const adapter = new SplitsAdapter({
  walletClient: createWalletClient({
    account: privateKeyToAccount(process.env.PRIVATE_KEY!),
    chain: base,
    transport: http(),
  }),
  chainId: 8453,
});

const recipients = await resolveWallets(distribution);

// Deploy a new splits contract for this resource
const { splitAddress } = await adapter.createSplit(recipients);
console.log("Split contract:", splitAddress);

// Any ETH sent to splitAddress is automatically routed to contributors
// according to their shares — no further action needed

// Update splits as provenance changes (new contributors, remixes, etc.)
await adapter.updateSplit(splitAddress, newRecipients);

import { SuperfluidAdapter } from "@provenancekit/payments";

const adapter = new SuperfluidAdapter({
  chainId: 8453, // Base
  superTokenAddress: "0x...", // e.g. USDCx on Base
  senderPrivateKey: process.env.PRIVATE_KEY!,
});

const recipients = await resolveWallets(distribution);
const totalFlowRate = BigInt("1000000000000"); // wei/second total (~86 USDC/day)

// Start streams to all contributors
await adapter.distributeFlow(recipients, totalFlowRate);
// Each contributor now receives: totalFlowRate × (share / 10_000) per second

// Update when provenance changes
await adapter.updateFlow(recipients, newTotalFlowRate);

// Stop all streams
await adapter.stopFlow(recipients);

import { DirectTransferAdapter } from "@provenancekit/payments";

const adapter = new DirectTransferAdapter({
  walletClient,
  publicClient,
});

const totalAmount = parseEther("1.0"); // 1 ETH to distribute

const recipients = await resolveWallets(distribution);
// Amounts are proportional to shares
const amounts = recipients.map(r => (totalAmount * BigInt(r.share)) / 10_000n);

await adapter.distribute(
  recipients.map((r, i) => ({ address: r.address, amount: amounts[i] }))
);

import { withExtension } from "@provenancekit/extensions";

const paymentExtension = {
  method: "superfluid",
  currency: "USDCx",
  chainId: 8453,
  splitAddress: "0x...",
  totalFlowRate: "1000000000000",
  recipients: [
    { entityId: "user:alice", share: 6000 },
    { entityId: "user:bob", share: 3000 },
    { entityId: "user:carol", share: 1000 },
  ],
};

const action = withExtension(baseAction, "ext:payment@1.0.0", paymentExtension);

import { ProvenanceKit } from "@provenancekit/sdk";
import { calculateDistributionFromBundle } from "@provenancekit/extensions";
import { SplitsAdapter } from "@provenancekit/payments";

async function setupRevenueSplitting(resourceCid: string) {
  const pk = new ProvenanceKit({ apiKey: process.env.PK_API_KEY! });

  // 1. Get the provenance graph for this resource
  const bundle = await pk.getBundle(resourceCid);

  // 2. Calculate distribution (basis points)
  const distribution = calculateDistributionFromBundle(bundle, 10_000);

  // 3. Resolve wallet addresses
  const recipients = await resolveWallets(distribution);

  // 4. Deploy 0xSplits contract
  const splitsAdapter = new SplitsAdapter({ walletClient, chainId: 8453 });
  const { splitAddress } = await splitsAdapter.createSplit(recipients);

  // 5. Record the payment setup in provenance
  await pk.entity({ id: "payment-contract:" + splitAddress, role: "organization" });

  return splitAddress;
}