ARCRYPT Docs

Intro to ARCRYPT

What is ARCRYPT

ARCRYPT is a private auction protocol on Solana built for single-item sales: one asset, one winner, no shared pool. Auction an NFT, a DAO treasury asset, or another single on-chain item in a fully sealed auction where no participant can see competing bids. By eliminating front-running and MEV, ARCRYPT ensures fair competition. The highest bidder is incentivised to pay what your asset is truly worth. Auctions on ARCRYPT go directly to the highest bidder (or, in a Vickrey auction, the highest bidder pays the second-highest bid). All USDC bids are entirely invisible, even if people track your wallet. ARCRYPT leverages state of the art cryptography and MPC technology to keep your money entirely hidden from the chain. Not only do we encrypt your bid, we hide the account that holds your bid - using CPI calls with the Umbra program. This makes it the first truly sealed auction platform made with Arcium. 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. ARCRYPT 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 an NFT or other single on-chain asset they own, and optionally list it on the ARCRYPT 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. Arcrypt aims to be the first protocol that entirely eliminates the possibility of bots outbidding humans, gives investors total confidentialty, and providing great price discovery.

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.

Ensuring privacy

How to use Arcrypt

Seller flow

• Connect your wallet and select the on-chain asset you want to auction (an NFT or other single item).
• If applicable, you can connect with Realms, MetaDAO or any DAO that accepts arbitrary instructions to propose the auction of a specific treasury asset.
• Set a floor price and choose an auction type (first-price or Vickrey).
• 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 auction: the highest bidder wins and pays exactly what they submitted.
• Vickrey (second-price) auction: the highest bidder wins but pays the second-highest bid, meaning incentive is bid your true value: nothing less and nothing more.

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 winning bid to the seller; all escrowed bidders who didn’t win can claim refunds.

Create a DAO proposal

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

Developers

Install the SDK with:

npm install @arcrypt/sdk

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

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

  authorityBase58: string;
  sourceTokenAccountBase58?: string;

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

  auctionType: "FirstPrice" | "Vickrey";
  assetKind: "Nft" | "MetadataOnly";

  metadataUri: string;
};

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

  auctionPk: PublicKey;

  bidAmountSol: string;     // your bid for the item

  nonceHex?: string;
};

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

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

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

  auctionPk: PublicKey;
  auctionData: any;

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

buildReclaimUnsoldTransaction()
buildClaimRefundTransaction()
buildSettleWinnerTransaction()

import { PublicKey } from "@solana/web3.js";
import { createAuction, createPlaceBid } from "@arcrypt/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(),
    minBidUsdc: "1.0",
    durationSecs: 3600,

    auctionType: "FirstPrice",
    assetKind: "Nft",

    metadataUri: "https://example.com/meta.json",
  });

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

    auctionPk: auction.auctionPda,

    bidAmountSol: "10",     // your bid for the item
  });

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

main().catch(console.error);