# Example Private Reserve Auction Dapp > Build a private reserve auction dApp on Midnight Network — hidden reserve price, public bids, private bidder identities. Covers private-reserve-auction.compact (no witnesses, persistentCommit, Map, Counter, disclose, receiveUnshielded/sendUnshielded), Next.js frontend, 1AM wallet integration, low-level deploy/call, indexer polling. Use for teaching privacy boundaries, commitment-based auctions, seller access control, or unshielded settlement. Triggers: private auction, reserve auction, silent auction, privacy boundary, persistentCommit, getDappPublicKey, unshielded claim, hidden price, bid commitment, seller reveal. Also use when extending locker-dapp or payment-dapp wallet/provider patterns to privacy-preserving auction flows. - Skill: `kali-decoder/example-private-reserve-auction-dapp` (Agent Skill) - Install (CLI): `npx skillmds@latest add kali-decoder/example-private-reserve-auction-dapp` - Raw SKILL.md: https://api.skillmd.com/api/skills/kali-decoder/example-private-reserve-auction-dapp/raw - Safety review: pending - Works with: Claude Code, Claude.ai, OpenAI Codex - Category: Web & Frontend - Author: kali-decoder (https://skillmd.com/u/kali-decoder) - Updated: 2026-09-17 - Page: https://skillmd.com/skills/kali-decoder/example-private-reserve-auction-dapp --- # Midnight Network Private Reserve Auction DApp A **private reserve auction contract** lets a seller hide the reserve price on-chain while bidders place public bids with private identities. The winner crosses the **privacy boundary** when claiming the item via unshielded NIGHT payment. **Runnable template:** Run `npm install && npm run compact && npm run sync:assets && npm run dev` after installing the [1AM wallet](https://1am.dev). **What this skill produces:** - `contract/` — `private-reserve-auction.compact` (no witnesses, Map, Counter) + compile scripts - `app/auction/` — Next.js client UI (seller deploy/close/reveal/claim + bidder place bid/claim item) - `lib/midnight.ts` — wallet session + patched indexer provider - `lib/auction.ts` — deploy, `bid`, `closeAuction`, `revealPrice`, `claimItem`, `claimProceeds`, ledger decode - `lib/address.ts` — Bech32 unshielded address → `{ bytes: Uint8Array }` for `UserAddress` circuit args - `lib/secret.ts` — generate/store 32-byte DApp secrets in `localStorage` - `public/zk/private-reserve-auction/` — ZK proving assets synced from contract build **Key architecture notes:** - **No witnesses** — caller auth uses circuit-private `_secret` → `getDappPublicKey(_secret)` compared to on-chain `organizer` - **Hidden reserve price** — committed via `persistentCommit(price, secret)`, revealed later by seller via `revealPrice` - **Public bids, private identities** — `bid` discloses bid amount but identity is `getDappPublicKey(secret)` hash - **Bid overwriting** — bidders can update their bid if higher; tracked in `Map, Uint<32>>` - **Auto-close** — auction closes when `bidCount == maxBids` - **Privacy boundary** — `claimItem` calls `receiveUnshielded(nativeToken(), publicPrice)` then `winnerClaimed.insert(disclose(address))` - **Seller becomes public** — `claimProceeds` calls `sendUnshielded(...)` to seller's `UserAddress` - **`disclose()` is a developer assertion** — it marks values safe for public domains; it does not perform the disclosure itself - Use `createUnprovenDeployTx` + `submitTxAsync` — not `deployContract()` (hangs on preview) - Wrap `indexerPublicDataProvider` with patched `queryContractState` (GraphQL `offset: null` bug) - Reserve price is `Uint<32>` on ledger (in Stars) but cast to `Uint<128>` for unshielded ops; 1 NIGHT = 1_000_000 Stars - UI accepts/display NIGHT; converts to Stars (×1,000,000) for contract - Persist seller/bidder `_secret` in `localStorage` — losing it means losing auth for that role - **Network: Preview** (hardcoded in `AuctionClient.tsx`) --- ## Workflow When helping the user, follow this sequence: 1. **Contract** — write `private-reserve-auction.compact`; compile with `npm run compact` 2. **Understand privacy boundary** — hidden price → public bids → reveal → claim (unshielded) → public settlement 3. **Providers** — `createConnectedSession` (from `references/midnight-session.md`) 4. **Deploy** — seller passes `(reservePriceStars, maxBidders, sellerSecret)` to constructor 5. **Bid** — bidders call `bid(bidAmountStars, userAddress, secret)` (public amount, private identity) 6. **Close** — seller calls `closeAuction(secret)` (or auto-closes when full) 7. **Reveal** — seller calls `revealPrice(reservePriceStars, secret)` (verified against commitment) 8. **Claim** — winner calls `claimItem(address, secret)` + pays reserve (crosses boundary) 9. **Proceeds** — seller calls `claimProceeds(address, secret)` after claim 10. **UI** — role cards (seller/bidder), auction status panel, indexer polling for public state --- ## 1) Project Structure ``` private-reserve-auction-dapp/ ├── package.json ├── next.config.mjs ├── postcss.config.mjs ├── lib/ │ ├── isomorphic-ws-fix.mjs │ ├── midnight.ts # session, patched provider, hex helpers │ ├── auction.ts # deploy, circuits, decode state │ ├── address.ts # Bech32 → UserAddress bytes │ └── secret.ts # crypto.getRandomValues + localStorage ├── app/ │ ├── globals.css │ ├── layout.tsx │ ├── page.tsx # landing page │ └── auction/ │ ├── page.tsx # server shell │ └── AuctionClient.tsx # seller + bidder UI ├── contract/ │ ├── package.json │ └── src/ │ ├── private-reserve-auction.compact │ ├── index.ts # CompiledContract.withVacantWitnesses │ └── managed/private-reserve-auction/ # compiler output (gitignored) ├── scripts/ │ └── sync-zk-assets.mjs # → public/zk/private-reserve-auction/ └── public/zk/private-reserve-auction/ # keys + zkir (gitignored until sync) ``` --- ## 2) Prerequisites ```bash node --version # 20+ docker --version # optional local devnet tests curl --proto '=https' --tlsv1.2 -sSf \ https://github.com/midnightntwrk/compact/releases/latest/download/compact-installer.sh | sh source $HOME/.local/bin/env ``` Browser: **1AM wallet** on `preview` with tNIGHT for bids and reserve payment. --- ## 3) Root `package.json` ```json { "name": "private-reserve-auction-dapp", "version": "0.1.0", "private": true, "type": "module", "scripts": { "dev": "next dev", "build": "npm run sync:assets && next build", "compact": "npm run compact --prefix contract", "sync:assets": "node scripts/sync-zk-assets.mjs", "postinstall": "echo 'All deps at root level'" }, "dependencies": { "@midnight-ntwrk/compact-js": "^2.5.0", "@midnight-ntwrk/compact-runtime": "0.16.0", "@midnight-ntwrk/ledger-v8": "8.0.3", "@midnight-ntwrk/midnight-js-contracts": "4.0.4", "@midnight-ntwrk/midnight-js-fetch-zk-config-provider": "4.0.4", "@midnight-ntwrk/midnight-js-indexer-public-data-provider": "4.0.4", "@midnight-ntwrk/midnight-js-network-id": "4.0.4", "@midnight-ntwrk/midnight-js-types": "4.0.4", "@midnight-ntwrk/wallet-sdk-address-format": "3.1.0", "@tailwindcss/postcss": "^4.3.2", "next": "^15.0.0", "postcss": "^8.5.16", "react": "^19.0.0", "react-dom": "^19.0.0", "tailwindcss": "^4.3.2" }, "devDependencies": { "@types/node": "^22.0.0", "@types/react": "^19.0.0", "@types/react-dom": "^19.0.0", "typescript": "^5.7.0" } } ``` --- ## 4) `contract/package.json` ```json { "name": "@private-reserve-auction/contract", "version": "0.1.0", "private": true, "type": "module", "scripts": { "compact": "compact compile src/private-reserve-auction.compact src/managed/private-reserve-auction" }, "devDependencies": { "@midnight-ntwrk/compact-runtime": "0.16.0" } } ``` Compile: ```bash npm run compact # → contract/src/managed/private-reserve-auction/{contract,keys,zkir}/ npm run sync:assets # → public/zk/private-reserve-auction/ ``` Expected circuits: `bid`, `closeAuction`, `revealPrice`, `claimItem`, `claimProceeds`. --- ## 5) `contract/src/private-reserve-auction.compact` ```compact pragma language_version 0.23; import CompactStandardLibrary; export enum AuctionState { OPEN, CLOSED, SETTLED } export sealed ledger organizer: Bytes<32>; export sealed ledger hiddenPrice: Bytes<32>; export sealed ledger maxBids: Uint<16>; export ledger publicPrice: Uint<32>; export ledger auctionState: AuctionState; export ledger bidders: Map, Uint<32>>; export ledger bidCount: Counter; export ledger highestBid: Uint<32>; export ledger winnerClaimed: Set; constructor(minPrice: Uint<32>, maxBidCount: Uint<16>, _secret: Bytes<32>) { assert(minPrice > 0, "Reserve price must be greater than zero"); assert(maxBidCount > 0, "Max bids must be greater than zero"); const pubKey = getDappPublicKey(_secret); organizer = disclose(pubKey); hiddenPrice = commitPrice(minPrice as Bytes<32>, _secret); maxBids = disclose(maxBidCount); publicPrice = 0; highestBid = 0; auctionState = AuctionState.OPEN; } export circuit bid(bidAmount: Uint<32>, _address: UserAddress, _secret: Bytes<32>): [] { assert(auctionState == AuctionState.OPEN, "Auction is not open"); assert(bidCount < maxBids, "Bids are full"); assert(bidAmount > 0, "Bid must be greater than zero"); const pubKey = getDappPublicKey(_secret); assert(pubKey != organizer, "Organizer cannot bid"); const bidderId = disclose(pubKey); const publicBid = disclose(bidAmount); if (bidders.member(bidderId)) { assert(bidders.lookup(bidderId) < publicBid, "New bid must be higher"); } bidders.insert(bidderId, publicBid); bidCount.increment(1); if (publicBid > highestBid) { highestBid = publicBid; } if (bidCount == maxBids) { auctionState = AuctionState.CLOSED; } } export circuit closeAuction(_secret: Bytes<32>): [] { const pubKey = getDappPublicKey(_secret); assert(organizer == pubKey, "Only organizer can close"); assert(auctionState == AuctionState.OPEN, "Auction already closed"); auctionState = AuctionState.CLOSED; } export circuit revealPrice(minPrice: Uint<32>, _secret: Bytes<32>): [] { const pubKey = getDappPublicKey(_secret); assert(organizer == pubKey, "Only organizer can reveal"); assert(auctionState == AuctionState.CLOSED, "Auction not closed"); const hashedPrice = commitPrice(minPrice as Bytes<32>, _secret); assert(hashedPrice == hiddenPrice, "Price mismatch — cannot change reserve"); publicPrice = disclose(minPrice); auctionState = AuctionState.SETTLED; } export circuit claimItem(_address: UserAddress, _secret: Bytes<32>): [] { assert(auctionState == AuctionState.SETTLED, "Auction not settled"); assert(highestBid >= publicPrice, "No valid winning bid"); assert(!winnerClaimed.member(disclose(_address)), "Already claimed"); const pubKey = getDappPublicKey(_secret); const bidderId = disclose(pubKey); assert(bidders.lookup(bidderId) == highestBid, "Not the highest bidder"); // Privacy boundary: winner pays reserve, identity revealed receiveUnshielded(nativeToken(), publicPrice as Uint<128>); winnerClaimed.insert(disclose(_address)); } export circuit claimProceeds(_address: UserAddress, _secret: Bytes<32>): [] { const pubKey = getDappPublicKey(_secret); assert(organizer == pubKey, "Not organizer"); assert(auctionState == AuctionState.SETTLED, "Auction not settled"); assert(winnerClaimed.size() > 0, "No winner claimed"); sendUnshielded( nativeToken(), publicPrice as Uint<128>, right(disclose(_address)) ); } circuit commitPrice(_price: Bytes<32>, _secret: Bytes<32>): Bytes<32> { return persistentCommit>(_price, _secret); } circuit getDappPublicKey(_secret: Bytes<32>): Bytes<32> { return persistentHash>>([pad(32, "private-auction:pk:"), _secret]); } ``` ### Privacy model summary | Phase | Bidder identity | On-chain data | |---|---|---| | Deploy | Seller hidden | `hiddenPrice` = `persistentCommit(price, secret)` hash | | Bid | **Hidden** (hash only) | Bid amount **public** in `Map`; bidder identity = hash | | Close | Hidden | `auctionState = CLOSED` | | Reveal | Hidden | `publicPrice` disclosed; verified against commitment | | **Claim** | **Public** | `receiveUnshielded` + address in `winnerClaimed` — **privacy boundary** | | Proceeds | Seller **public** | `sendUnshielded` to seller address | ### Always-public Compact domains - Ledger fields (after `disclose()` or safe commits) - Circuit return values from exported circuits - Contract-to-contract calls - **Unshielded token transfers** (`receiveUnshielded`, `sendUnshielded`) - **Bid amounts** (disclosed in `bid` circuit) --- ## 6) `contract/src/index.ts` No witnesses — use `withVacantWitnesses`. **Use lazy `await import()` pattern** to avoid SSR issues and ensure `CompiledContract` is resolved from the correct module. ```typescript import { CompiledContract } from '@midnight-ntwrk/compact-js'; import { sampleSigningKey, ContractState } from '@midnight-ntwrk/compact-runtime'; let _contractModule: any = null; let _compiledContract: any = null; let _ledgerFn: any = null; export async function getCompiledContract(zkPath?: string): Promise { if (!_compiledContract) { if (!_contractModule) { _contractModule = await import('./managed/private-reserve-auction/contract/index.js'); } _compiledContract = CompiledContract.make( 'private-reserve-auction', _contractModule.Contract, ); _compiledContract = CompiledContract.withVacantWitnesses(_compiledContract); } return _compiledContract; } export async function getLedger(): Promise { if (!_ledgerFn) { if (!_contractModule) { _contractModule = await import('./managed/private-reserve-auction/contract/index.js'); } _ledgerFn = _contractModule.ledger; } return _ledgerFn; } export { sampleSigningKey, ContractState }; ``` --- ## 7) `lib/address.ts` Decode Bech32 unshielded addresses for `UserAddress` circuit args. ```typescript import { MidnightBech32m, UnshieldedAddress } from '@midnight-ntwrk/wallet-sdk-address-format'; export function bech32ToUserAddress(bech32: string, networkId: string): { bytes: Uint8Array } { const parsed = MidnightBech32m.parse(bech32).decode(UnshieldedAddress, networkId); return { bytes: new Uint8Array(parsed.data) }; } ``` Never pass raw Bech32 strings or shielded coin public keys where `UserAddress` is expected. The `{ bytes }` wrapper is required for `UserAddress` but **not** for `Bytes<32>` — those are raw `Uint8Array`. --- ## 8) `lib/secret.ts` ```typescript import { fromHex, toHex } from './midnight'; export function generateSecret(): Uint8Array { const bytes = new Uint8Array(32); crypto.getRandomValues(bytes); return bytes; } export function saveSecret( role: 'seller' | 'bidder', contractAddress: string, secret: Uint8Array, ) { localStorage.setItem(`private-auction:${role}:${contractAddress}`, toHex(secret)); } export function loadSecret( role: 'seller' | 'bidder', contractAddress: string, ): Uint8Array | null { const hex = localStorage.getItem(`private-auction:${role}:${contractAddress}`); return hex ? fromHex(hex) : null; } ``` --- ## 9) Provider Setup — `lib/midnight.ts` ```typescript import { setNetworkId } from '@midnight-ntwrk/midnight-js-network-id'; import { indexerPublicDataProvider } from '@midnight-ntwrk/midnight-js-indexer-public-data-provider'; import { FetchZkConfigProvider } from '@midnight-ntwrk/midnight-js-fetch-zk-config-provider'; import { ContractState } from '@midnight-ntwrk/compact-runtime'; import type { MidnightProvider, WalletProvider } from '@midnight-ntwrk/midnight-js-types'; export type ConnectedSession = { api: any; config: any; providers: { privateStateProvider: ReturnType; publicDataProvider: ReturnType; zkConfigProvider: FetchZkConfigProvider; proofProvider: { proveTx: (unprovenTx: any) => Promise }; walletProvider: WalletProvider; midnightProvider: MidnightProvider; }; unshieldedAddress: string; coinPublicKeyBytes: Uint8Array; }; export function fromHex(hex: string): Uint8Array { const h = hex.startsWith('0x') ? hex.slice(2) : hex; return Uint8Array.from(h.match(/.{1,2}/g)!.map((b) => parseInt(b, 16))); } export function toHex(bytes: Uint8Array): string { return Array.from(bytes) .map((b) => b.toString(16).padStart(2, '0')) .join(''); } function coinPublicKeyToBytes(pk: unknown): Uint8Array { if (pk instanceof Uint8Array) return pk.length === 32 ? pk : pk.slice(0, 32); if (typeof pk === 'string') { const hex = pk.startsWith('0x') ? pk.slice(2) : pk; if (hex.length === 64 && /^[0-9a-fA-F]+$/.test(hex)) return fromHex(hex); return new Uint8Array(32); } if (Array.isArray(pk)) { return new Uint8Array(pk.length >= 32 ? pk.slice(0, 32) : [...pk, ...new Uint8Array(32 - pk.length)]); } if (pk && typeof pk === 'object' && 'bytes' in (pk as object)) { return coinPublicKeyToBytes((pk as { bytes: unknown }).bytes); } return new Uint8Array(32); } function createPrivateStateProvider() { let scope = ''; const stateStore = new Map(); const signingKeyStore = new Map(); const key = (id: string) => `${scope}:${id}`; return { setContractAddress(address: string) { scope = address; }, async set(id: string, state: unknown) { stateStore.set(key(id), state); }, async get(id: string) { return stateStore.get(key(id)) ?? null; }, async remove(id: string) { stateStore.delete(key(id)); }, async clear() { stateStore.clear(); }, async setSigningKey(addr: string, k: unknown) { signingKeyStore.set(addr, k); }, async getSigningKey(addr: string) { return signingKeyStore.get(addr) ?? null; }, async removeSigningKey(addr: string) { signingKeyStore.delete(addr); }, async clearSigningKeys() { signingKeyStore.clear(); }, async exportPrivateStates(): Promise { throw new Error('Not implemented.'); }, async importPrivateStates(): Promise { throw new Error('Not implemented.'); }, async exportSigningKeys(): Promise { throw new Error('Not implemented.'); }, async importSigningKeys(): Promise { throw new Error('Not implemented.'); }, }; } function createPatchedPublicDataProvider(queryUrl: string, subscriptionUrl: string) { const base = indexerPublicDataProvider(queryUrl, subscriptionUrl); return { ...base, async queryContractState(contractAddress: string, config?: unknown) { if (config) return base.queryContractState(contractAddress, config as never); const res = await fetch(queryUrl, { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify({ query: `query LATEST_CONTRACT_STATE($address: HexEncoded!) { contractAction(address: $address) { state } }`, variables: { address: contractAddress }, }), }); if (!res.ok) throw new Error(`Indexer HTTP error: ${res.status}`); const payload = await res.json(); if (payload.errors?.length) { throw new Error(payload.errors.map((e: { message: string }) => e.message).join('; ')); } const action = payload.data?.contractAction ?? null; return action ? ContractState.deserialize(fromHex(action.state)) : null; }, }; } export async function createConnectedSession( api: any, zkAssetBasePath: string, ): Promise { const [config, unshieldedAddress, shieldedAddress] = await Promise.all([ api.getConfiguration(), api.getUnshieldedAddress(), api.getShieldedAddresses(), ]); setNetworkId(config.networkId); const zkConfigProvider = new FetchZkConfigProvider( new URL(zkAssetBasePath, window.location.origin).toString(), window.fetch.bind(window), ); const provingProvider = await api.getProvingProvider(zkConfigProvider); const proofProvider = { async proveTx(unprovenTx: any) { const { CostModel } = await import('@midnight-ntwrk/ledger-v8'); return unprovenTx.prove(provingProvider, CostModel.initialCostModel()); }, }; const walletProvider: WalletProvider = { getCoinPublicKey: () => shieldedAddress.shieldedCoinPublicKey, getEncryptionPublicKey: () => shieldedAddress.shieldedEncryptionPublicKey, balanceTx: async (tx: any) => { const txHex = toHex(tx.serialize()); const balanced = await api.balanceUnsealedTransaction(txHex); if (!balanced?.tx) throw new Error('balanceUnsealedTransaction returned invalid result'); const { Transaction } = await import('@midnight-ntwrk/ledger-v8'); return Transaction.deserialize('signature', 'proof', 'binding', fromHex(balanced.tx)); }, }; const midnightProvider: MidnightProvider = { submitTx: async (tx: any) => { const txHex = toHex(tx.serialize()); const result = await api.submitTransaction(txHex); if (typeof result === 'string' && result) return result; if (result?.transactionId) return result.transactionId; if (result?.id) return result.id; return txHex.slice(0, 64); }, }; return { api, config, providers: { privateStateProvider: createPrivateStateProvider(), publicDataProvider: createPatchedPublicDataProvider(config.indexerUri, config.indexerWsUri), zkConfigProvider, proofProvider, walletProvider, midnightProvider, }, unshieldedAddress: unshieldedAddress.unshieldedAddress, coinPublicKeyBytes: coinPublicKeyToBytes(shieldedAddress.shieldedCoinPublicKey), }; } export async function pollForState( queryUrl: string, contractAddress: string, maxAttempts = 120, intervalMs = 2000, ): Promise { for (let i = 0; i < maxAttempts; i++) { const res = await fetch(queryUrl, { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify({ query: `query LATEST_CONTRACT_STATE($address: HexEncoded!) { contractAction(address: $address) { state } }`, variables: { address: contractAddress }, }), }); if (res.ok) { const payload = await res.json(); const state = payload.data?.contractAction?.state; if (state) return state; } await new Promise((r) => setTimeout(r, intervalMs)); } throw new Error(`Contract state not indexed after ${(maxAttempts * intervalMs) / 1000}s`); } export async function detectWallet(): Promise { const w = (window as any).midnight?.['1am'] ?? Object.values((window as any).midnight ?? {})[0]; if (!w) throw new Error('No Midnight wallet extension found'); return w; } ``` **Key implementation details:** - `createPatchedPublicDataProvider` wraps the SDK's `indexerPublicDataProvider` and intercepts `queryContractState`. When no config is passed (the polling path), it falls back to a raw `fetch` + hand-written GraphQL query that omits the `offset` parameter entirely — this sidesteps the GraphQL `offset: null` bug without needing a separate SDK version fix. - `coinPublicKeyToBytes` defensively normalizes four input shapes: `Uint8Array`, hex string, plain `number[]`, and `{ bytes: ... }` wrapper. This is necessary because different wallet SDK versions return coin public keys in different formats. - `createPrivateStateProvider` is a clean in-memory Map-based provider with no `@midnight-ntwrk` dependency — avoids pulling in the SDK's own private state provider which would add another WASM bundle. - **Lazy WASM imports** — `proofProvider.proveTx` dynamically imports `@midnight-ntwrk/ledger-v8` for `CostModel`, and `balanceTx` does the same for `Transaction`. This avoids loading WASM-backed modules at module-evaluation time, which matters because the same pattern prevents the "dual WASM instance" bug (see troubleshooting). If you statically import `ledger-v8` at the top of this file, it will conflict with `compact-runtime`'s own WASM instance. - `createConnectedSession` front-loads `getConfiguration`, `getUnshieldedAddress`, and `getShieldedAddresses` into a single `Promise.all`. If any of these throw (e.g. wallet not fully initialized, or user rejected the connection prompt), the entire session creation fails. The caller should catch this and surface a meaningful error — see `connectWallet` in `AuctionClient.tsx`. - `detectWallet` throws if no wallet is found rather than returning `null`. Callers must `.catch()` or the rejection will be unhandled. The UI component uses `.then().catch()` to translate this into a `false` state — see the bug note in troubleshooting. --- ## 10) `lib/auction.ts` Uses `getCompiledContract()` (lazy singleton) and the correct arg format for Compact 0.23+. ```typescript import { createUnprovenDeployTx, submitCallTxAsync, submitTxAsync } from '@midnight-ntwrk/midnight-js-contracts'; import { getCompiledContract, getLedger, sampleSigningKey, ContractState } from '../contract/src/index'; import type { ConnectedSession } from './midnight'; import { fromHex, pollForState } from './midnight'; import { bech32ToUserAddress } from './address'; const PRIVATE_STATE_ID = 'PrivateAuctionState'; export const ZK_PATH = '/zk/private-reserve-auction'; const AUCTION_STATE_NAMES = ['OPEN', 'CLOSED', 'SETTLED'] as const; export type AuctionStateName = (typeof AUCTION_STATE_NAMES)[number]; let _compiledContract: any = null; async function makeCompiledContract() { if (!_compiledContract) { _compiledContract = await getCompiledContract(ZK_PATH); } return _compiledContract; } function setSize(value: unknown): number { if (typeof value === 'number') return value; if (value && typeof value === 'object' && 'size' in value) { const size = (value as { size: unknown }).size; if (typeof size === 'function') return Number((size as () => number)()); if (typeof size === 'number') return size; } return 0; } export async function deployAuction( session: ConnectedSession, reservePriceNight: number, maxBidders: number, sellerSecret: Uint8Array, ): Promise { const reservePriceStars = reservePriceNight * 1_000_000; const cc = await makeCompiledContract(); const deployTxData = await (createUnprovenDeployTx as any)( { zkConfigProvider: session.providers.zkConfigProvider, walletProvider: session.providers.walletProvider, }, { compiledContract: cc, args: [BigInt(reservePriceStars), BigInt(maxBidders), sellerSecret], privateStateId: PRIVATE_STATE_ID, initialPrivateState: {}, signingKey: sampleSigningKey(), }, ); const contractAddress = deployTxData.public.contractAddress; await (submitTxAsync as any)(session.providers, { unprovenTx: deployTxData.private.unprovenTx }); await session.providers.privateStateProvider.setContractAddress(contractAddress); await session.providers.privateStateProvider.set(PRIVATE_STATE_ID, {}); await session.providers.privateStateProvider.setSigningKey( contractAddress, deployTxData.private.signingKey, ); return contractAddress; } async function call( session: ConnectedSession, contractAddress: string, circuitId: string, args: unknown[], ) { const cc = await makeCompiledContract(); await (submitCallTxAsync as any)(session.providers, { compiledContract: cc, contractAddress, circuitId, args, privateStateId: PRIVATE_STATE_ID, }); } export const placeBid = (session: ConnectedSession, contractAddress: string, bidAmountNight: number, userAddress: { bytes: Uint8Array }, bidderSecret: Uint8Array) => call(session, contractAddress, 'bid', [BigInt(bidAmountNight * 1_000_000), userAddress, bidderSecret]); export const closeAuction = (session: ConnectedSession, contractAddress: string, sellerSecret: Uint8Array) => call(session, contractAddress, 'closeAuction', [sellerSecret]); export const revealPrice = (session: ConnectedSession, contractAddress: string, reservePriceNight: number, sellerSecret: Uint8Array) => call(session, contractAddress, 'revealPrice', [BigInt(reservePriceNight * 1_000_000), sellerSecret]); export const claimItem = (session: ConnectedSession, contractAddress: string, userAddress: { bytes: Uint8Array }, bidderSecret: Uint8Array) => call(session, contractAddress, 'claimItem', [userAddress, bidderSecret]); export const claimProceeds = (session: ConnectedSession, contractAddress: string, sellerAddress: { bytes: Uint8Array }, sellerSecret: Uint8Array) => call(session, contractAddress, 'claimProceeds', [sellerAddress, sellerSecret]); export async function decodeAuctionState(stateHex: string) { const contractState = ContractState.deserialize(fromHex(stateHex)); const ledger = await getLedger(); const l = ledger(contractState.data) as any; const stateIdx = Number(l.auctionState); return { auctionState: (AUCTION_STATE_NAMES[stateIdx] ?? `UNKNOWN(${stateIdx})`) as AuctionStateName | string, auctionStateIndex: stateIdx, maxBidders: Number(l.maxBids), publicPriceNight: Number(l.publicPrice) / 1_000_000, highestBidNight: Number(l.highestBid) / 1_000_000, bidCount: setSize(l.bidCount), bidderCount: setSize(l.bidders), }; } export async function fetchAuctionState(queryUrl: string, contractAddress: string) { const hex = await pollForState(queryUrl, contractAddress); return decodeAuctionState(hex); } export function userAddressFromSession(session: ConnectedSession) { return bech32ToUserAddress(session.unshieldedAddress, session.config.networkId); } ``` **Key details:** - `args` use `BigInt(...)` for `Uint<32>` fields, not plain numbers - `Bytes<32>` args are passed as raw `Uint8Array`, **not** wrapped in `{ bytes: ... }`. `UserAddress` args require the `{ bytes }` wrapper - `ledger()` is resolved via `getLedger()` from the contract's own compiled module - `setSize()` handles both `.size` (property) and `.size()` (method) since compiled `Set`/`Counter` ledger fields vary by SDK version - Reserve price in NIGHT is converted to Stars (×1,000,000) before passing to contract --- ## 11) Frontend — `app/auction/AuctionClient.tsx` ```tsx 'use client'; import { useState, useCallback, useEffect, useRef } from 'react'; import { detectWallet, createConnectedSession, pollForState } from '@/lib/midnight'; import { deployAuction, placeBid, closeAuction, revealPrice, claimItem, claimProceeds, fetchAuctionState, userAddressFromSession, ZK_PATH, } from '@/lib/auction'; import { generateSecret, loadSecret, saveSecret } from '@/lib/secret'; import type { ConnectedSession } from '@/lib/midnight'; type Role = 'seller' | 'bidder'; const STATE_LABELS: Record = { OPEN: 'Open for Bids', CLOSED: 'Bidding Closed', SETTLED: 'Settled', }; export default function AuctionClient() { const [session, setSession] = useState(null); const [role, setRole] = useState('bidder'); const [contractAddress, setContractAddress] = useState(''); const [auctionState, setAuctionState] = useState> | null>(null); const [error, setError] = useState(''); const [connecting, setConnecting] = useState(false); const [busy, setBusy] = useState(false); const [statusMessage, setStatusMessage] = useState(''); const [walletInstalled, setWalletInstalled] = useState(null); const mountedRef = useRef(true); const [reservePriceNight, setReservePriceNight] = useState('0.01'); const [maxBidders, setMaxBidders] = useState('5'); const [bidAmountNight, setBidAmountNight] = useState('0.02'); useEffect(() => { detectWallet() .then((w) => setWalletInstalled(w !== null)) .catch(() => setWalletInstalled(false)); return () => { mountedRef.current = false; }; }, []); const withLoading = useCallback(async ( message: string, fn: (setStatus: (msg: string) => void) => Promise, ): Promise => { setBusy(true); setError(''); setStatusMessage(message); try { const result = await fn((msg: string) => { if (mountedRef.current) setStatusMessage(msg); }); return result; } catch (e) { if (mountedRef.current) { setError(e instanceof Error ? e.message : String(e)); } throw e; } finally { if (mountedRef.current) { setBusy(false); setStatusMessage(''); } } }, []); const refresh = useCallback(async () => { if (!session || !contractAddress) return; try { const state = await fetchAuctionState(session.config.indexerUri, contractAddress); if (mountedRef.current) setAuctionState(state); } catch (e) { if (mountedRef.current) setError(e instanceof Error ? e.message : 'Refresh failed'); } }, [session, contractAddress]); useEffect(() => { void refresh(); }, [refresh]); const connectWallet = useCallback(async () => { setConnecting(true); setError(''); try { const wallet = await detectWallet(); if (!wallet) { setError('1AM wallet not detected. Please install the 1AM browser extension.'); return; } const api = await wallet.connect('preview'); const s = await createConnectedSession(api, ZK_PATH); setSession(s); } catch (e) { setError(e instanceof Error ? e.message : 'Failed to connect wallet'); } finally { setConnecting(false); } }, []); const handleDeploy = useCallback(async () => { if (!session) return; await withLoading('Deploying auction contract…', async (setStatus) => { const secret = generateSecret(); const addr = await deployAuction( session, Number(reservePriceNight), Number(maxBidders), secret, ); setContractAddress(addr); saveSecret('seller', addr, secret); setStatus('Waiting for indexer…'); const state = await fetchAuctionState(session.config.indexerUri, addr); setAuctionState(state); }); }, [session, withLoading, reservePriceNight, maxBidders]); const handlePlaceBid = useCallback(async () => { if (!session || !contractAddress) return; await withLoading('Placing bid (proving + submitting)…', async (setStatus) => { let secret = loadSecret('bidder', contractAddress); if (!secret) { secret = generateSecret(); saveSecret('bidder', contractAddress, secret); } await placeBid(session, contractAddress, Number(bidAmountNight), userAddressFromSession(session), secret); setStatus('Waiting for indexer…'); const state = await fetchAuctionState(session.config.indexerUri, contractAddress); setAuctionState(state); }); }, [session, contractAddress, withLoading, bidAmountNight]); const handleCloseAuction = useCallback(async () => { if (!session || !contractAddress) return; const secret = loadSecret('seller', contractAddress); if (!secret) { setError('Seller secret not found.'); return; } await withLoading('Closing auction…', async (setStatus) => { await closeAuction(session, contractAddress, secret); setStatus('Waiting for indexer…'); const state = await fetchAuctionState(session.config.indexerUri, contractAddress); setAuctionState(state); }); }, [session, contractAddress, withLoading]); const handleRevealPrice = useCallback(async () => { if (!session || !contractAddress) return; const secret = loadSecret('seller', contractAddress); if (!secret) { setError('Seller secret not found.'); return; } await withLoading('Revealing reserve price…', async (setStatus) => { await revealPrice(session, contractAddress, Number(reservePriceNight), secret); setStatus('Waiting for indexer…'); const state = await fetchAuctionState(session.config.indexerUri, contractAddress); setAuctionState(state); }); }, [session, contractAddress, withLoading, reservePriceNight]); const handleClaimItem = useCallback(async () => { if (!session || !contractAddress) return; const secret = loadSecret('bidder', contractAddress); if (!secret) { setError('Bidder secret not found. Place a bid first.'); return; } await withLoading('Claiming item (proving + submitting)…', async (setStatus) => { await claimItem(session, contractAddress, userAddressFromSession(session), secret); setStatus('Waiting for indexer…'); const state = await fetchAuctionState(session.config.indexerUri, contractAddress); setAuctionState(state); }); }, [session, contractAddress, withLoading]); const handleClaimProceeds = useCallback(async () => { if (!session || !contractAddress) return; const secret = loadSecret('seller', contractAddress); if (!secret) { setError('Seller secret not found.'); return; } await withLoading('Claiming proceeds…', async (setStatus) => { await claimProceeds(session, contractAddress, userAddressFromSession(session), secret); setStatus('Waiting for indexer…'); const state = await fetchAuctionState(session.config.indexerUri, contractAddress); setAuctionState(state); }); }, [session, contractAddress, withLoading]); const reset = useCallback(() => { setContractAddress(''); setAuctionState(null); setError(''); }, []); if (walletInstalled === false) { return (

1AM Wallet Required

Please install the 1AM browser extension for Midnight Network.

Install 1AM Wallet
); } const state = auctionState; return (

Private Reserve Auction

Hidden reserve price, public bids, private bidder identities

{!session && (
)} {session && (

Wallet

Unshielded: {session.unshieldedAddress}

Network: {session.config.networkId}

)} {session && !contractAddress && (