Getting Started

Obelysk is a privacy-first DeFi protocol and verifiable AI platform on Starknet. It combines ElGamal encryption with GKR zero-knowledge proofs to enable fully private trading, transfers, and staking — all verified 100% on-chain with no trusted setup.

Mainnet Contracts

Privacy Pools

Token Pairs

0.3%

Protocol Fee

What You Can Build

Obelysk has two complementary tracks that work together through the VM31Bridge:

🛡️

Track 1 — Privacy DeFi

Deposit tokens into shielded pools, swap privately via Ekubo, trade in dark pool auctions, send stealth payments, and stake SAGE. All amounts encrypted with ElGamal.

🧠

Track 2 — ZKML Verification

Prove neural network inference on-chain using GKR interactive proofs. The verifier walks the computation graph layer by layer, checking sumcheck polynomials.

🔐

Encrypted Balances

Token amounts are never visible on-chain. Track 1 uses ElGamal ciphertexts, Track 2 uses fixed-denomination UTXO commitments with Poseidon2-M31.

⚡

GPU-Accelerated Proving

CUDA kernels for sumcheck, FFT, and Merkle operations. 50-112x speedup over CPU. Qwen3-14B proven at 3.04s/layer on H100.

Install the SDK

npm install @bitsage/sdk

Quick Start

You don't need an account for read-only queries. Pass an account only when you need to sign transactions (deposits, swaps, staking).

Initialize the Client

import { ObelyskClient } from '@bitsage/sdk/obelysk';
import { Account, RpcProvider } from 'starknet';

const provider = new RpcProvider({
  nodeUrl: 'https://starknet-mainnet.g.alchemy.com/starknet/version/rpc/v0_7/YOUR_KEY',
});

const account = new Account(provider, '0xYOUR_ADDRESS', '0xYOUR_PRIVATE_KEY');

const obelysk = new ObelyskClient({
  network: 'mainnet',
  rpcUrl: provider.nodeUrl,
  account,
});

Your First Private Transaction

Deposit into a Privacy Pool

Send tokens into a shielded pool. You receive a note — a cryptographic receipt containing your secret and nullifier. Save it securely.

Tokens are now shielded

Your deposit is added to a Merkle commitment tree. The link between your address and the deposit is broken.

Withdraw later

Present your note to generate a zero-knowledge proof (Merkle inclusion + range proof). The protocol verifies without knowing which deposit is yours.

// Deposit 0.1 ETH into the privacy pool
const note = await obelysk.privacyPool.deposit({
  token: 'eth',
  amount: '0.1',
});

// CRITICAL: Save this note! It's the only way to withdraw.
console.log('Secret:', note.secret);
console.log('Nullifier:', note.nullifier);
console.log('Leaf index:', note.leafIndex);

Save Your Note

The note contains the secret and nullifier needed to withdraw. If you lose it, your funds are permanently locked in the pool. There is no recovery mechanism.

Read Protocol State (No Account Needed)

// Dark Pool auction state
const epoch = await obelysk.darkPool.getEpochInfo();
console.log(`Epoch ${epoch.epochNumber}: ${epoch.phase}`);

// Privacy pool stats
const stats = await obelysk.privacyPool.getPoolStats('eth');
console.log('ETH deposits:', stats.totalDeposits);

// Staking info
const staked = await obelysk.staking.getTotalStaked();
console.log('Total SAGE staked:', staked);

Cryptographic Foundations

Every proof in Obelysk is real cryptographic math — no stubs, no placeholders, no trusted setup.

Primitive	Use Case	Security
ElGamal	Balance encryption	Additively homomorphic on STARK curve
Schnorr Proofs	Ownership verification	6 proofs per confidential transfer
Pedersen Commitments	Value hiding	Computationally binding, perfectly hiding
Poseidon2-M31	UTXO commitments	124-bit collision resistance
GKR + Sumcheck	Neural network proving	42-255x trace reduction
Merkle Trees	Deposit inclusion	LeanIMT, depth-20

Next Steps

Privacy Architecture — understand how the dual-track system works
Privacy Features (SDK) — deposits, stealth payments, dark pool trading
Trading & Staking — OTC orders, shielded swaps, SAGE staking
GKR Protocol — deep dive into the ZKML verification system
Deployed Contracts — all 14 mainnet contract addresses