Builder Codes for App Developers

import { createConfig, http } from "wagmi";
import { base } from "wagmi/chains";
import { Attribution } from "ox/erc8021";

// Get your Builder Code from Base Dashboard > Settings > Project Settings > Builder Code
const DATA_SUFFIX = Attribution.toDataSuffix({
  codes: ["YOUR-BUILDER-CODE"],
});

export const config = createConfig({
  chains: [base],
  transports: {
    [base.id]: http(),
  },
  dataSuffix: DATA_SUFFIX,
});

import { useSendTransaction } from "wagmi";
import { parseEther } from "viem";

function SendButton() {
  const { sendTransaction } = useSendTransaction();

  return (
    <button
      onClick={() =>
        sendTransaction({
          to: "0x70997970c51812dc3a010c7d01b50e0d17dc79c8",
          value: parseEther("0.01"),
        })
      }
    >
      Send ETH
    </button>
  );
}

import { createWalletClient, http } from "viem";
import { base } from "viem/chains";
import { Attribution } from "ox/erc8021";

// Get your Builder Code from Base Dashboard > Settings > Project Settings > Builder Code
const DATA_SUFFIX = Attribution.toDataSuffix({
  codes: ["YOUR-BUILDER-CODE"],
});

export const walletClient = createWalletClient({
  chain: base,
  transport: http(),
  dataSuffix: DATA_SUFFIX,
});

import { parseEther } from "viem";
import { walletClient } from "./client";

const hash = await walletClient.sendTransaction({
  to: "0x70997970c51812dc3a010c7d01b50e0d17dc79c8",
  value: parseEther("0.01"),
});

// `provider` is the connected wallet's EIP-1193 provider
const [address] = await provider.request({ method: "eth_requestAccounts" });
const chainId = await provider.request({ method: "eth_chainId" }); // "0x2105" on Base, "0x14a34" on Base Sepolia

const userId = address.toLowerCase();

// The user switched accounts (new identity) or disconnected (empty array)
provider.on("accountsChanged", (accounts: string[]) => {});
// The user switched networks; activity on other chains will not carry your Base attribution
provider.on("chainChanged", (chainId: string) => {});

const { id } = await provider.request({
  method: "wallet_sendCalls",
  params: [{ version: "2.0.0", chainId: "0x2105", from: address, atomicRequired: true, calls, capabilities }],
});

// Poll until the bundle settles. 100 = pending, 200 = confirmed, 4xx/5xx/600 = failed or partial
const { status, receipts } = await provider.request({
  method: "wallet_getCallsStatus",
  params: [id],
});

const transactionHashes = receipts?.map((receipt) => receipt.transactionHash) ?? [];

import { createPublicClient, decodeFunctionData, http, isAddressEqual, parseEventLogs, type Hash } from "viem";
import { base } from "viem/chains";
import { entryPoint06Abi, entryPoint06Address, entryPoint07Abi, entryPoint07Address } from "viem/account-abstraction";
import { Attribution } from "ox/erc8021";

const client = createPublicClient({ chain: base, transport: http() });

const BUILDER_CODE = "YOUR-BUILDER-CODE";

export async function getAttributedActivity(hash: Hash) {
  const [tx, receipt] = await Promise.all([
    client.getTransaction({ hash }),
    client.getTransactionReceipt({ hash }),
  ]);

  const block = await client.getBlock({ blockNumber: receipt.blockNumber });
  const common = {
    transactionHash: hash,
    blockNumber: receipt.blockNumber,
    timestamp: Number(block.timestamp),
  };

  // ERC-4337: the outer transaction is sent by a bundler to the EntryPoint.
  // The user is each UserOperation's sender, and the suffix sits in its callData.
  const entryPoint =
    tx.to && isAddressEqual(tx.to, entryPoint07Address) ? { abi: entryPoint07Abi } :
    tx.to && isAddressEqual(tx.to, entryPoint06Address) ? { abi: entryPoint06Abi } :
    undefined;

  if (entryPoint) {
    const { args } = decodeFunctionData({ abi: entryPoint.abi, data: tx.input });
    const ops = (args?.[0] ?? []) as readonly { sender: `0x${string}`; callData: `0x${string}` }[];
    const events = parseEventLogs({ abi: entryPoint.abi, eventName: "UserOperationEvent", logs: receipt.logs });

    return ops.map((op) => {
      const event = events.find((e) => isAddressEqual(e.args.sender, op.sender));
      return {
        ...common,
        sender: op.sender.toLowerCase(),
        success: event?.args.success ?? false,
        attributed: Attribution.fromData(op.callData)?.codes?.includes(BUILDER_CODE) ?? false,
      };
    });
  }

  // EOA transaction: the user is tx.from and the suffix is at the end of tx.input.
  return [{
    ...common,
    sender: tx.from.toLowerCase(),
    success: receipt.status === "success",
    attributed: Attribution.fromData(tx.input)?.codes?.includes(BUILDER_CODE) ?? false,
  }];
}