ARCRYPT Docs

Intro to ARCRYPT

What is ARCRYPT

ARCRYPT is a private auction platform on Solana designed to maximize value without exposing bids. Launch or List tokens, NFTs, or DAO treasury assets in fully sealed auctions 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. NFTs launched on the Arcrypt marktplace go directly to the highest bidder. Tokens launched on Arcrypt go through a uniform FDV based auction, and the bids generate liquidity for an automatically generated Raydium swap pool once the auction closes. This enables token launches in just a few clicks with 100% resistance to bot manipulation. 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 tokens, NFTs, or other on-chain assets they own, and optionally list them 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 launchpad 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 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 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.
• Uniform-price auction: used for selling tokens. Bidders submit:
  • Amount (how many units they want)
  • Max price per unit
  Winners are selected by highest price, and:
  • All winners pay the same final clearing price
  • This price is the lowest winning price needed to clear
  This enables fair price discovery while distributing assets across multiple participants, and developing a substantial liquidity pool before being launched on the DEX.

Settlement

• At auction close, bids are revealed and the winner is determined according to the chosen auction type.
• On-chain settlement transfers the asset(s) to the winner(s) and the winning bids to seed the Raydium pool; all escrowed bidders who didn’t win can claim refunds.
• Tokens launched through ARCRYPT are automatically made available for trading on the Raydium DEX immediately after settlement.

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 treasury tokens. Just specify the amount and 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;

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

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

  metadataUri: string;

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

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

  auctionPk: PublicKey;

  bidAmountSol: string;     // total bid
  bidPriceSol?: string;     // REQUIRED for uniform auctions

  nonceHex?: string;
};

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

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

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(),
    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: "10",     // total size
    bidPriceSol: "2.5",     // price per unit (only for uniform)
  });

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

main().catch(console.error);