Build the Future on
CryptoChain

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

// Native AMM swap precompile — 12K gas vs 145K on Ethereum
interface INativeSwap {
    function swap(
        address tokenIn,
        address tokenOut,
        uint256 amountIn,
        uint256 minAmountOut,
        address recipient
    ) external returns (uint256 amountOut);
}

contract MyDeFiProtocol {
    address constant NATIVE_SWAP = 0x0000000000000000000000000000000000000022;

    function swapTokens(
        address _in, address _out,
        uint256 _amt, uint256 _min
    ) external returns (uint256) {
        return INativeSwap(NATIVE_SWAP).swap(
            _in, _out, _amt, _min, msg.sender
        );
    }
}

import { CryptoChain, Staking, parseUnits } from '@cryptochain/sdk';

const cc      = new CryptoChain({ network: 'mainnet' });
const staking = new Staking(cc);

// Get all validators sorted by APY (highest first)
const validators = await staking.getValidators({ sortBy: 'apy' });
const best       = validators[0];

console.log(`Best validator: ${best.name} @ ${best.apy}% APY`);

// Delegate 100 CCT to the top validator
const tx = await staking.delegate({
  validator: best.address,
  amount:    parseUnits('100', 18),
  wallet,
});

console.log(`Staked! TX: ${tx.hash}`);

// Check delegation rewards after some blocks
const rewards = await staking.getPendingRewards(wallet.address);
console.log(`Pending: ${cc.formatCCT(rewards)} CCT`);

import { CryptoChain, ZKWallet, ZKProof } from '@cryptochain/sdk';

const cc     = new CryptoChain({ network: 'mainnet' });
const zkWallet = await ZKWallet.create(cc, privateKey);

// Generate ZK proof locally (~1.2s on modern hardware)
const proof = await ZKProof.generateTransfer({
  from:    zkWallet.shieldedAddress,
  to:      '0xRecipientShieldedAddress...',
  amount:  parseUnits('50', 18),
  token:   'CCT',
});

console.log(`Proof size: ${proof.size} bytes`);
console.log(`Proving time: ${proof.provingMs}ms`);

// Submit shielded transaction — amount hidden on-chain
const tx = await zkWallet.sendShielded({ proof, privacy: true });
console.log(`Private TX: ${tx.hash} (amount hidden)`);

// Recipient can verify receipt without revealing amount
const verified = await cc.verifyZKProof(tx.hash);
console.log(`Verified: ${verified}`);

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

// Governance vote precompile — 3,200 gas (vs 44K for contract)
interface IGovernance {
    enum Vote { Against, For, Abstain }

    function castVote(uint256 proposalId, Vote support)
        external returns (uint256 weight);

    function delegate(address delegatee) external;
    function getVotingPower(address account)
        external view returns (uint256);
}

contract DAOModule {
    address constant GOV = 0x0000000000000000000000000000000000000025;

    function voteForProposal(uint256 id) external {
        uint256 weight = IGovernance(GOV).castVote(
            id, IGovernance.Vote.For
        );
        emit Voted(msg.sender, id, weight);
    }

    event Voted(address indexed voter, uint256 proposal, uint256 weight);
}