Build an Offer Bot

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

// Fail loudly when the endpoint is missing rather than quietly falling back to
// the public Base RPC. Set BASE_RPC_URL, or set USE_PUBLIC_BASE_RPC=true to
// choose the slow, throttled path on purpose.
const rpcUrl = process.env.BASE_RPC_URL;
if (!rpcUrl && process.env.USE_PUBLIC_BASE_RPC !== "true") {
  throw new Error(
    "Missing BASE_RPC_URL. Ask the user for their own Base RPC endpoint " +
      "(Alchemy, QuickNode, Infura, or similar), or set USE_PUBLIC_BASE_RPC=true " +
      "to run against the public endpoint with pacing.",
  );
}

export const usingPublicRpc = !rpcUrl;

// viem retries 429s and 5xx responses on its own. Give the public endpoint more
// room before it gives up.
export const transport = http(rpcUrl, {
  retryCount: usingPublicRpc ? 5 : 3,
  retryDelay: usingPublicRpc ? 1_000 : 250,
});

// Small on a dedicated endpoint, generous on the public one. Use it between
// targets in the bot loop, not just between RPC calls.
export const STEP_DELAY_MS = usingPublicRpc ? 1_000 : 250;

export const pause = (ms: number) =>
  new Promise((resolve) => setTimeout(resolve, ms));

type Address = string;
type Hex = string;
type BidHash = string;

type TypedData = {
  domain: Record<string, unknown>;
  types: Record<string, Array<{ name: string; type: string }>>;
  primaryType: string;
  message: Record<string, unknown>;
};

type StoredTraitIndexBid = {
  id: number;
  bidHash: BidHash;
  bidderEOA: Address;
  receivingChonkId: number;
  traitIndex: number;
  traitType: number;
  currency: Address;
  currencyDecimals: number;
  amount: string;
  deadline: string;
  salt: string;
  permit2Nonce: string;
  permit2Deadline: string;
  signature: Hex;
  eip712TypedData: TypedData | null;
  status: "active" | "settling" | "canceled" | "settled" | "expired";
  replacedByBidHash: BidHash | null;
  settledTraitId: number | null;
  settlementTxHash: Hex | null;
  createdAt: string;
  updatedAt: string;
  canceledAt: string | null;
  settledAt: string | null;
};

type PublicTraitIndexBid = Omit<
  StoredTraitIndexBid,
  "salt" | "permit2Nonce" | "permit2Deadline" | "signature" | "eip712TypedData"
>;

type ApiErrorResponse = {
  error: string;
  code: string;
  details?: unknown;
  issues?: unknown[];
};

curl -s https://www.chonks.xyz/api/trait-index-bids/build \
  -X POST \
  -H "Content-Type: application/json" \
  -d '{
    "bidderEOA": "0xYourBidderWallet",
    "receivingChonkId": 12345,
    "traitIndex": 57,
    "currency": "usdc",
    "amount": "25.50",
    "expirationDays": 7
  }'

type BuildOfferResponse = {
  bidHash: BidHash;
  traitIndex: number;
  traitType: number;
  receivingChonkId: number;
  currency: {
    symbol: "USDC" | "WETH";
    address: Address;
    decimals: number;
  };
  amount: {
    human: string;
    raw: string;
  };
  deadline: number;
  expirationDays: 1 | 3 | 7;
  salt: string;
  marketplaceSpender: Address;
  typedData: TypedData;
  createRequest: {
    bidHash: BidHash;
    bidderEOA: Address;
    receivingChonkId: number;
    traitIndex: number;
    traitType: number;
    currency: Address;
    currencyDecimals: number;
    amount: string;
    deadline: number;
    expirationDays: 1 | 3 | 7;
    salt: string;
    permit2Nonce: string;
    permit2Deadline: number;
    typedData: TypedData;
  };
  preflight: {
    balance: {
      balance: string;
      requiredAmount: string;
      hasEnoughBalance: boolean;
    };
    approval: {
      required: boolean;
      isSufficient: boolean;
      allowance: string;
      minimumAmount: string;
      recommendedAmount: string;
      spender: Address;
      permit2Spender: Address;
      marketplaceSpender: Address;
      function: "approve(address,uint256)";
      transaction: null | {
        chainId: 8453;
        to: Address;
        value: "0";
        data: Hex;
      };
    };
    replacement: {
      isReplacement: boolean;
      previousBidHash: BidHash | null;
      minimumAmount: string | null;
      minimumHumanAmount: string | null;
    };
  };
};

import { createWalletClient, type Hex } from "viem";
import { privateKeyToAccount } from "viem/accounts";
import { base } from "viem/chains";

const rawPrivateKey = process.env.BIDDER_PRIVATE_KEY;
if (!rawPrivateKey) throw new Error("Missing BIDDER_PRIVATE_KEY");

const privateKey = (
  rawPrivateKey.startsWith("0x") ? rawPrivateKey : `0x${rawPrivateKey}`
) as Hex;
const account = privateKeyToAccount(privateKey);
// `transport` comes from the RPC Endpoint section above. A bare http() falls
// back to the public Base endpoint and will rate-limit a bot that runs targets
// in a loop.
const wallet = createWalletClient({ account, chain: base, transport });

async function readJson(response: Response) {
  const body = await response.json();
  if (!response.ok) throw body;
  return body;
}

const build = await fetch("https://www.chonks.xyz/api/trait-index-bids/build", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({
    bidderEOA: account.address,
    receivingChonkId: 12345,
    traitIndex: 57,
    currency: "usdc",
    amount: "25.50",
    expirationDays: 7,
  }),
}).then(readJson);

if (!build.preflight.balance.hasEnoughBalance) {
  throw new Error("Fund the bidder EOA before signing this Offer.");
}

if (build.preflight.approval.required) {
  await wallet.sendTransaction({
    to: build.preflight.approval.transaction.to,
    data: build.preflight.approval.transaction.data,
    value: 0n,
  });
}

const signature = await wallet.signTypedData(build.typedData);

const created = await fetch("https://www.chonks.xyz/api/trait-index-bids", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({
    ...build.createRequest,
    signature,
  }),
}).then(readJson);

console.log(created.bid.id, created.bid.bidHash);

type CreateOfferResponse = {
  bid: StoredTraitIndexBid;
};

curl -s "https://www.chonks.xyz/api/trait-index-bids?traitIndex=57&traitType=1"

curl -s "https://www.chonks.xyz/api/trait-index-bids?traitIndex=57&traitType=1&currency=usdc"

type ListActiveOffersResponse = {
  bids: PublicTraitIndexBid[];
  limit: number;
  offset: number;
};

const bidId = 123;
const bidHash = "0xabc...";

const cancelMessage = [
  "Cancel Chonks TraitIndex Offer",
  "Bid id: " + bidId,
  "Bid hash: " + bidHash,
].join("\n");

const signature = await wallet.signMessage({
  account,
  message: cancelMessage,
});

const canceled = await fetch("https://www.chonks.xyz/api/trait-index-bids/cancel", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({
    id: bidId,
    bidHash,
    signature,
  }),
}).then(readJson);

type CancelOfferResponse = {
  bid: StoredTraitIndexBid;
  signedMessage: string;
};

curl -s https://www.chonks.xyz/api/chonk-bids/build \
  -X POST \
  -H "Content-Type: application/json" \
  -d '{
    "bidderEOA": "0xYourBidderWallet",
    "chonkId": 12345,
    "currency": "usdc",
    "amount": "25.50",
    "expirationDays": 7
  }'

Cancel Chonks exact Chonk Offer
Bid id: <id>
Bid hash: <bidHash>