ARCIBID logo

ARCIBID Docs

Everything there is to know

Intro to ARCIBID

What is ARCIBID

ARCIBID is a private auction platform on Solana designed to maximize value without exposing bids. List tokens, NFTs, or DAO treasury assets in fully sealed auctions where no participant can see competing bids. By eliminating front-running and MEV, ARCIBID ensures fair competition. The highest bidder is incentivised to pay what your asset is truly worth. ARCIBID leverages state of the art cryptography and MPC technology to keep your money entirely hidden from the chain.

Selling assets is harder than it looks. OTC deals rely on negotiation and often do not result in the best price. Public auctions expose bids in real time, inviting bots, MEV, and front-running that distort true price discovery. ARCIBID solves this with sealed, private auctions - removing information leakage and ensuring bidders compete based on true value, not strategy or manipulation. While it can integrate directly with DAOs to auction treasury assets through proposals, you don’t need to be a DAO to use it. Anyone can auction tokens, NFTs, or other on-chain assets they own, and optionally list them on the ARCIBID marketplace to reach a wider pool of serious bidders without sacrificing privacy.

The Mission

We firmly believe privacy is a central human right. Nobody needs to know what you do with your data, and that includes your money.

What is Arcium

Arcium is a next-generation privacy layer on Solana, built using Multi-Party Computation (MPC). This means bid amounts are never exposed in plaintext—not even to the network. Bids are encrypted client-side and processed collectively by Arcium nodes, which compute the highest bid without revealing any individual inputs.

At its core, Arcium enables totally decentralized confidential computation—allowing data to remain private while still being used in verifiable on-chain logic. This is critical for sealed auctions, where information leakage would otherwise undermine fairness.

ARCIBID leverages the Arcium Confidential Token Standard to securely escrow bidder funds. This introduces program-controlled private balances for the first time, enabling fully private, trustless auctions without compromising on-chain settlement or transparency of outcomes.

Ensuring privacy

ARCIBID automatically generates an UMBRA encrypted token account (ETA) associated with your wallet address. This ETA is the link between the private world and the public chain. Funds can be moved in and out of your ARCIBID account in the Profile page.

This enables you to move SPL tokens in and out of a private balance arbitrarily, thus obscuring your activity. All bids are made with USDC. Placing a bid will transfer funds from your ETA to an escrow account (transferring any missing funds from your public wallet, then to the ETA, then to the escrow) which is controlled by the ARCIBID program. The escrow funds exist within the shielded pool.

The UMBRA program performs a rescue cipher of the bid amount against the ARCIBID mixed execution environment, controlled by the Arcium MPC network. ARCIBID validates the ciphertext and sends it to the MXE where we compare it against the current highest bid(s). The exact computation depends on the type of auction (see below).

Your bid or bidder identity is never revealed during this process, as the bid comparison computation is performed across hundreds of nodes in the Arcium network, such that no individual node can ever determine any information about the computation or its result.

We will eventually migrate to the confidential token standard to simplify the flow and directly read escrow accounts within the MXE, rather than sending the encrypted amount as ciphertext to the MXE.

How it works

Seller flow

  • Connect your wallet and select the on-chain address / asset you want to auction (tokens, NFTs).
  • If applicable, you can connect with Realms, MetaDAO or any DAO that accepts arbitrary instructions to propose the auction of a specific number of treasury tokens.
  • Set a floor price and choose an auction type (first-price, Vickrey, or uniform).
  • Specify a custom duration (up to 30 days) and attach optional metadata (descriptions, provenance, external links).
  • Publish the auction — bids remain encrypted until the reveal step, preserving bidder privacy throughout the process.

Auction types

  • First-price (normal) auction: the highest bidder pays the amount they submitted.
  • Vickrey (second-price) auction: the highest bidder wins, but pays the second-highest bid. Incentivizes bidders to submit true valuations.
  • Uniform-price auction: used for multiple identical items — winning bidders all pay the same clearing price (e.g., the highest losing bid or the lowest winning bid depending on rules).

Bidding & escrow

When a bidder places funds, ARCIBID automatically wraps them into Arcium’s confidential token standard and escrows them securely.

Settlement

  • At auction close, bids are revealed and the winner is determined according to the chosen auction type.
  • On-chain settlement transfers the asset to the winner and the proceeds to the seller; all escrowed bidders who didn’t win are automatically refunded.
  • Every transfer is verifiable while preserving bid privacy—so outcomes are auditable without leaking individual bid amounts.

Create a DAO proposal

Connect directly with Realms, MetaDAO or any DAO that accepts arbitrary instructions to call the ARCIBID program and propose to auction treasury tokens. Just specify the amount and duration and auction rules as normal.

Create an ARCIBID DAO

We are rapidly developing a new DAO Launchpad that tokenizes part of the initial token sale that are bought via sealed bids. This is excellent for new startups looking for maximal price discovery. We will also build Realms integration to enable you to start a Realms DAO with a section of the initial treasury available via sealed-auction.

Developers

Install the SDK with:

npm install @arcibid/sdk

Note: the package is not deployed yet — use the SDK directly from the repository for now.

Core Functions

createAuction
type CreateAuctionParams = {
  programClient: any;
  programId: PublicKey;
  publicKey: PublicKey;

  authorityBase58: string;
  sourceTokenAccountBase58?: string;

  minBidSol: string;           // e.g. "1.5"
  durationSecs: number;        // auction length in seconds

  auctionType: "FirstPrice" | "Vickrey" | "Uniform" | "ProRata";
  assetKind: "Fungible" | "Nft" | "MetadataOnly";

  metadataUri: string;

  tokenMint?: string;          // required for tokens/NFTs
  saleAmountToken?: string;    // e.g. "100.0"
};

Creates an auction instruction and returns a transaction bundle ready to send.

createPlaceBid
type CreatePlaceBidParams = {
  programClient: any;
  programId: PublicKey;
  publicKey: PublicKey;

  auctionPk: PublicKey;
  bidAmountSol: string;  // e.g. "2.0"
  nonceHex?: string;     // optional custom nonce
};

Encrypts and submits a bid using Arcium MPC. Funds are escrowed privately.

createDetermineWinner
type CreateDetermineWinnerParams = {
  programClient: any;
  programId: PublicKey;
  publicKey: PublicKey;

  auctionPk: PublicKey;
  which: "first" | "vickrey" | "uniform" | "proRata";
};

Triggers encrypted winner computation via Arcium.

createSettlement
type CreateSettlementParams = {
  programClient: any;
  programId: PublicKey;
  publicKey: PublicKey;

  auctionPk: PublicKey;
  auctionData: any;

  escrowExists?: boolean;
  action?: "auto" | "reclaimUnsold" | "claimRefund" | "settleWinner";
};

Automatically determines whether to reclaim, refund, or settle the auction.

Low-level settlement builders

For advanced usage, ARCIBID also exposes lower-level transaction builders used internally by createSettlement. These allow you to explicitly control settlement behavior.

buildReclaimUnsoldTransaction()
buildClaimRefundTransaction()
buildSettleWinnerTransaction()

These functions return transaction bundles and require the same core inputs (programClient, programId, publicKey, auctionPk, auctionData).

Minimal Example

import { PublicKey } from "@solana/web3.js";
import { createAuction, createPlaceBid } from "@arcibid/sdk";

async function main() {
  const programClient = /* your Anchor client */;
  const programId = new PublicKey("PROGRAM_ID");
  const wallet = new PublicKey("WALLET_PUBKEY");

  // 1. Create auction
  const auction = await createAuction({
    programClient,
    programId,
    publicKey: wallet,

    authorityBase58: wallet.toBase58(),
    minBidSol: "1.0",
    durationSecs: 3600,

    auctionType: "FirstPrice",
    assetKind: "Fungible",

    metadataUri: "https://example.com/meta.json",
    tokenMint: "TOKEN_MINT",
    saleAmountToken: "100",
  });

  // 2. Place bid
  const bid = await createPlaceBid({
    programClient,
    programId,
    publicKey: wallet,

    auctionPk: auction.auctionPda,
    bidAmountSol: "2.5",
  });

  console.log("Auction TX:", auction.transaction);
  console.log("Bid TX:", bid.transaction);
}

main().catch(console.error);

Rust SDK

Coming soon.

FAQ

Are bids really private?
Yes. Bids are encrypted using Arcium confidential compute.
← Back to home