Architecture

SynapticChain uses a unique S=0 architecture where the compiler drives parallel scheduling, eliminating lock contention on hot paths.

Server Topology

SCBFT Consensus

Synaptic Consensus BFT combines BLS threshold signatures with a fast commit pipeline:

1. Transactions enter mempool, sorted by gas price + arrival time
2. Leader proposes a block every 2 seconds
3. Validators sign with BLS partial signatures
4. Threshold aggregation produces a single BLS group signature
5. Block is final after 2/3+1 signatures collected (<500ms)

Cross-Shard Atomicity

Atomic commits across all 6 shards use a two-phase protocol with proof-of-locking. If any shard fails to lock, the entire transaction is rolled back.

S=0 Parallel Execution

The compiler analyzes data dependencies and schedules non-conflicting transactions to run in parallel on separate CPU cores. Hot paths use lock-free data structures (DashMap, AtomicU64, mpsc channels).

Quick Start

1. Connect Your Wallet

const wallet = window.SynapticWallet;
await wallet.connect();
const address = wallet.getAddress();
console.log("Connected:", address); // syn1abc...

2. Get Test Tokens

Visit the Academy and use the faucet, or the wallet will auto-grant 1000 SYN in demo mode.

3. Query a Contract

const res = await fetch('https://rpc.synapticchain.xyz', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    jsonrpc: '2.0',
    id: 1,
    method: 'syn_callViewFunction',
    params: {
      contract: 'syn195fk50708yz0hjujhcuxnmxq0r9xk5x9ndc44z',
      function: 'get_pool_count',
      args: []
    }
  })
});
const data = await res.json();
console.log("Pools:", data.result);

4. Send a Transaction

const tx = {
  contract: 'syn195fk50708yz0hjujhcuxnmxq0r9xk5x9ndc44z',
  function: 'swap_exact_in',
  args: ['SYN_tUSDT', 1000000, 'SYN', 0],
  gasLimit: 6000,
  value: 0
};
const txHash = await wallet.signAndSend(tx);
console.log("Tx sent:", txHash);

API Reference

JSON-RPC Endpoints

View Functions (No Gas)

// syn_callViewFunction — read contract state
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "syn_callViewFunction",
  "params": {
    "contract": "syn195fk...",
    "function": "get_pool_reserve0",
    "args": ["syn1token0...", "syn1token1..."]
  }
}

// syn_getBalance — check SYN balance
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "syn_getBalance",
  "params": { "address": "syn1user..." }
}

// syn_getTransactionReceipt — verify a tx
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "syn_getTransactionReceipt",
  "params": { "hash": "0xabc123..." }
}

Transaction Submission

// syn_sendTransaction — state-changing call (requires signing)
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "syn_sendTransaction",
  "params": {
    "contract": "syn195fk...",
    "function": "swap_exact_in",
    "args": ["SYN_tUSDT", 1000000, "SYN", 0],
    "gasLimit": 6000,
    "value": 0,
    "sender": "syn1user...",
    "signature": "base64_bls_signature"
  }
}

WebSocket Subscriptions

// Connect to wss://api.synapticchain.xyz/ws
// Subscribe to new blocks
{ "jsonrpc": "2.0", "id": 1, "method": "syn_subscribe", "params": ["newBlocks"] }

// Subscribe to contract events
{ "jsonrpc": "2.0", "id": 2, "method": "syn_subscribe", "params": ["events", "syn195fk..."] }

Smart Contracts

Five core dApp contracts are deployed on the Alpha testnet and verified.

Contract Addresses

AMM DEX

Key Functions

• create_pool(token_a, token_b, fee_tier) — Deploy new liquidity pool
• add_liquidity(pool_id, amount_a, amount_b, min_a, min_b) — Provide liquidity
• remove_liquidity(pool_id, shares, min_a, min_b) — Withdraw liquidity
• swap_exact_in(pool_id, amount_in, token_in, min_out) — Swap tokens
• get_pool_reserve0(token_a, token_b) — View reserve (verified)

Events

PoolCreated, LiquidityAdded, LiquidityRemoved, Swap, Sync

Lending Protocol

Key Functions

• deposit(token, amount) — Supply collateral, mint aTokens
• withdraw(token, amount) — Withdraw (checks health factor)
• borrow(token, amount) — Borrow against collateral
• repay(token, amount) — Repay debt
• liquidate(user, collateral_token, debt_token, debt_to_cover) — Liquidate

Events

Deposit, Withdraw, Borrow, Repay, Liquidation

Perpetuals

Key Functions

• open_position(market_id, collateral, size, is_long) — Open leveraged position
• close_position(market_id, size_to_close) — Close position
• add_collateral(market_id, additional) — Add margin
• liquidate(trader, market_id) — Liquidate if margin ratio < 1%

Prediction Market

Key Functions

• create_market(question, end_time, fee_bps, min_bet, max_bet) — Launch market
• buy_shares(market_id, outcome, amount) — Buy YES/NO shares
• sell_shares(market_id, outcome, shares) — Sell shares
• resolve_market(market_id, vrf_proof) — Resolve with VRF
• claim_payout(market_id) — Claim winnings

NFT Marketplace

Key Functions

• create_collection(name, symbol, max_supply, base_uri, mint_price, royalty_bps, recipient)
• mint(collection_id, metadata_uri) — Mint NFT
• list_for_sale(collection_id, token_id, price) — List NFT
• cancel_listing(collection_id, token_id) — Delist
• buy(collection_id, token_id) — Purchase (handles royalties)
• batch_mint(collection_id, count, metadata_uris) — Mint up to 20 at once

SynapticLang v2

SynapticLang is a custom smart contract DSL with compile-time verification and native sharding support.

Language Features

Example: Simple Token

#[contract]
module MyToken {
  #[state] balances: Map<Address, u128>;
  #[state] total_supply: u128;
  const DECIMALS: u8 = 6;

  #[gas_limit(5000)]
  fn transfer(to: Address, amount: u128) {
    verify amount > 0;
    let sender = msg.sender;
    let sender_bal = balances.get(sender).unwrap_or(0);
    verify sender_bal >= amount;
    balances.insert(sender, sender_bal - amount);
    let to_bal = balances.get(to).unwrap_or(0);
    balances.insert(to, to_bal + amount);
    emit Transfer { from: sender, to, amount };
  }
}

Compilation

# Compile .syn to bytecode
synlang compile token.syn --output token.syn.bin

# Deploy via RPC
curl -X POST https://rpc.synapticchain.xyz \
  -d '{"jsonrpc":"2.0","method":"syn_sendTransaction","params":{"type":"contract_deploy","bytecode":"BASE64...","gasLimit":50000}}'

Web4 Identity

SynapticChain's Web4 identity layer eliminates seed phrases through embedded device key cryptography.

How It Works

1. Device generates an ed25519 keypair on first use
2. Private key is encrypted with AES-GCM using a device-bound secret
3. Public key is encoded as a bech32m address (prefix: syn1)
4. No seed phrase, no password — biometric or PIN unlocks the key

Wallet SDK Methods

Transaction Object

interface SynapticTx {
  contract: string;      // Contract address
  function: string;        // Function name
  args: any[];             // Ordered arguments
  gasLimit: number;        // Max gas units
  value?: number;           // Micro-SYN to send
}

Demo Mode

If the wallet RPC is unreachable, the SDK falls back to demo mode with 1000 SYN automatically granted. This lets developers test dApp integration without a live validator connection.

Validator Setup

Requirements

Installation

# 1. Download synapticchain-core
git clone https://github.com/syntechz/synapticchain-core.git
cd synapticchain-core

# 2. Build
make build-release

# 3. Generate validator keys
./synapticchain keygen --output /opt/synapticchain/keys

# 4. Configure
nano /opt/synapticchain/config/node.toml
# Set: shard_id = 0..5, server = alpha|bravo, bootnodes = [...]

# 5. Start
./synapticchain run --config /opt/synapticchain/config/node.toml

# 6. Stake (minimum 10,000 SYN)
./synapticchain stake --amount 10000000000000 --validator $(cat keys/address)

Monitoring

Each validator exposes Prometheus metrics on :3000/metrics and node-exporter metrics on :9100/metrics. The unified API gateway aggregates these for the testnet explorer dashboard.

Tutorials

Tutorial 1: Deploy Your First Contract

// 1. Write contract in SynapticLang
// 2. Compile: synlang compile mycontract.syn
// 3. Deploy via interactive script:
node scripts/deploy-all.js
// 4. Select contract, confirm gas, wait for receipt
// 5. Verify: curl -X POST /rpc -d '{"method":"syn_callViewFunction","params":{"contract":"NEW_ADDRESS","function":"get_owner"}}'

Tutorial 2: Mint an NFT

const NFT_CONTRACT = 'syn12x0vw0d6cn6wpumwaxd8gxw333edz9hnez3n6z';

// 1. Create collection
const tx1 = {
  contract: NFT_CONTRACT,
  function: 'create_collection',
  args: ['My Art', 'ART', 1000, 'https://metadata.example.com/', 1000000, 250, wallet.getAddress()],
  gasLimit: 15000
};
const collectionTx = await wallet.signAndSend(tx1);

// 2. Mint NFT
const tx2 = {
  contract: NFT_CONTRACT,
  function: 'mint',
  args: [1, 'https://metadata.example.com/1.json'],
  gasLimit: 8000
};
const mintTx = await wallet.signAndSend(tx2);

// 3. List for sale
const tx3 = {
  contract: NFT_CONTRACT,
  function: 'list_for_sale',
  args: [1, 1, 5000000], // collection 1, token 1, 5 SYN
  gasLimit: 6000
};
await wallet.signAndSend(tx3);

Tutorial 3: Use the DEX

const DEX = 'syn195fk50708yz0hjujhcuxnmxq0r9xk5x9ndc44z';

// 1. Check pool reserves
const reserves = await rpc.call('syn_callViewFunction', {
  contract: DEX,
  function: 'get_pool_reserve0',
  args: ['SYN', 'tUSDT']
});

// 2. Estimate swap output
const estimate = await rpc.call('syn_estimateGas', {
  contract: DEX,
  function: 'swap_exact_in',
  args: ['SYN_tUSDT', 1000000, 'SYN', 0],
  sender: wallet.getAddress()
});

// 3. Execute swap
const tx = {
  contract: DEX,
  function: 'swap_exact_in',
  args: ['SYN_tUSDT', 1000000, 'SYN', 900000],
  gasLimit: Math.floor(estimate.gas * 1.2)
};
const hash = await wallet.signAndSend(tx);

Tutorial 4: Set Up a Payment Widget

// Include synaptic-wallet-sdk.js on your page
// Add the payment widget:
<div id="synaptic-pay" data-amount="1000000" data-recipient="syn1merchant...">
</div>
<script>
SynapticPay.init('#synaptic-pay', {
  onSuccess: (tx) => console.log('Paid:', tx.hash),
  onError: (err) => console.error('Failed:', err)
});
</script>

Chrome Extension

The SynapticChain Chrome extension (Manifest V3) injects window.SynapticWallet into every webpage for seamless dApp integration.

Features

• Background service worker for persistent key storage
• AES-GCM + PBKDF2 encrypted key storage
• Bech32m syn1 addresses
• Origin-locked dApp permissions
• Auto-lock after 10 minutes inactivity
• Private key import/export for recovery

Installation

# 1. Download synaptic-extension.zip
# 2. Unzip to a folder
# 3. Chrome → Extensions → Developer Mode ON
# 4. Load Unpacked → Select the unzipped folder
# 5. Extension icon appears in toolbar

# Verify injection:
console.log(window.SynapticWallet); // Object with connect(), signAndSend(), etc.

Permissions

dApp Integration

// In your dApp, detect the wallet:
if (window.SynapticWallet) {
  const wallet = window.SynapticWallet;
  const address = await wallet.connect();
  // User approved — proceed with contract calls
} else {
  // Prompt user to install extension
  showInstallPrompt('https://chrome.google.com/webstore/detail/...');
}

Glossary