BUIDL with Smart Privacy

Better dApps require smarter privacy. Use cutting-edge tools from Oasis to add customizable confidentiality to any Web3 & AI application.

Why Build On Oasis?

Why Build On Oasis?

Bringing Privacy to Web3 & Ai

Oasis is the go-to network for on-chain privacy. Confidential ParaTimes on Oasis enable developers to build privacy-enabled dApps that bring more real-world use cases to blockchain and AI.

CUSTOMIZATION

Oasis’ multi-layer, modular architecture enables multiple ParaTimes, each optimized for different use cases, to coexist and process transactions in parallel with shared consensus. ParaTimes are entirely customizable, ensuring that the Oasis network will always be able to provide developers with the right tool for the job.

HIGH PERFORMANCE

The Oasis scales performance via the ParaTime layer to offer high throughput and low latency. The Oasis Sapphire ParaTime achieves 6s block times and instant finality; blocks are final once they are mined.

EASE OF DEVELOPMENT

Oasis offers privacy-enabled EVM, and WASM-based ParaTimes as well as a familiar standard EVM environment to accommodate a diverse array of the brightest and boldest blockchain developers and applications. Solidity developers can get started building privacy-enabled dApps immediately!

The building blocks
of  Smart Privacy 

Sapphire is the first and only confidential EVM in production. Sapphire empowers developers to build EVM-based dApps using smart contracts with Smart Privacy – 100% confidential, 100% public, or anywhere in between.

The Oasis Privacy Layer (OPL) adds instant privacy to existing dApps running on any EVM network. As the industry-leading EVM-compatible Smart Privacy solution, OPL redefines how Web3 & AI developers engineer confidential smart contracts.

ROSE Wallet is the official non-custodial wallet for holding, sending and receiving digital assets on the Oasis Network. Through the ROSE Wallet, users also have access to industry-leading custody options and easy on-ramps that have integrated with the Oasis ecosystem.

The Oasis Explorer provides an easy-to-use frontend for diving deep into onchain activity. By surfacing powerful data and analytics across all Oasis runtime environments, the Explorer matches the versatility of the Oasis protocol with equivalent screeners, visualizations, and analytics for monitoring ecosystem growth and development.

Nexus is the premiere data-fetching backend for the Oasis ecosystem for explorers and wallets. Nexus is not just an indexer–it serves as a critical conduit for accessing onchain data for the Oasis Network.

Unlocking Smart Privacy Features on the Oasis Network

Smart Contacts

contract MessageBox {
   string private _message;
   address public author;    function setMessage(string calldata in_message) external {
       _message = in_message;
       author = msg.sender;
   }    function message() external view returns (string memory) {
     if (msg.sender!=author) {
       revert("not allowed");
     }
     return _message;
   }
}

bytes32 key = ... ;
bytes32 nonce = ... ;
bytes memory text = "plain text";
bytes memory ad = "additional data";
bytes memory encrypted = Sapphire.encrypt(key, nonce, text, ad);
bytes memory decrypted = Sapphire.decrypt(key, nonce, encrypted, ad);

bytes memory seed = hex"0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef";
bytes memory publicKey;
bytes memory privateKey;
(publicKey, privateKey) = Sapphire.generateSigningKeyPair(Sapphire.SigningAlg.Ed25519Pure, seed);

function signTransaction(uint64 nonce, uint256 gasPrice)
    internal returns (bytes memory)
{
    (address signerAddr, bytes32 signerSecret) = EthereumUtils.generateKeypair();

    payable(signerAddr).transfer(1 ether);

    return EIP155Signer.sign(
     signerAddr, signerSecret,
     EIP155Signer.EthTx({
            nonce: nonce,
            gasPrice: gasPrice,
            gasLimit: 250000,
            to: address(this),
            value: 0,
            data: data,
            chainId: block.chainid
        }));
}

import {Host, Result} from "@oasisprotocol/sapphire-contracts/contracts/OPL.sol";

contract Sender is Host {
 event HeardReply(string);  

constructor(address _receiver) Host(_receiver) {
   registerEndpoint("listenToReply", _listenToReply);
 }  function sendToListener(string memory _message) external payable {
   postMessage("confirmMessage", abi.encode(_message));
 }  function _listenToReply(bytes calldata _args) internal returns (Result) {
   (string memory reply) = abi.decode(_args, (string));
   emit HeardReply(reply);
   return Result.Success;
  }
}

Client Integration

import '@oasisprotocol/sapphire-hardhat';functionn setMessage(addr: string, message: string) {
 // Wrapped MessageBox instance.
 let messageBox =
   await hre.ethers.getContractAt('MessageBox', addr);
 // Encrypted setMessage transaction.
 await messageBox.setMessage(message);
);export default const config: HardhatUserConfig = {
 networks: {
   'sapphire': {
     url: 'https://sapphire.oasis.io',
     chainId: 0x5afe,
   },
   'sapphire-testnet': {
     url: 'https://testnet.sapphire.oasis.dev',
     chainId: 0x5aff,
   },
 },
};export default config;

import * as sapphire from '@oasisprotocol/sapphire-paratime';
import { type MessageBox__factory } from 'my-messagebox-backend';

const provider = sapphire.wrap(window.ethereum);

functionn setMessage(addr: string, message: string) {
 // Wrapped MessageBox instance.
 const messageBox =
   MessageBox__factory.connect(addr, provider.getSigner());
 // Encrypted setMessage transaction.
 await messageBox.setMessage(message);
}

import { sapphireTestnet } from 'viem/chains';
import * as sapphire from '@oasisprotocol/sapphire-paratime';

const provider = sapphire.wrap(window.ethereum! as EIP1193Provider);
const walletClient = createWalletClient({
 chain: sapphireTestnet,
 transport: custom(provider),
})

import sapphire "github.com/oasisprotocol/sapphire-paratime/clients/go"


func main() {
 privateKey, err := crypto.HexToECDSA("")
 if err != nil {
   log.Fatal(err)
 }
 c, err := ethclient.Dial("https://testnet.sapphire.oasis.dev")
 if err != nil {
   log.Fatal(err)
 }
 var client *sapphire.WrappedBackend
 client, err = sapphire.WrapClient(*c, func(digest [32]byte) ([]byte, error) { return crypto.Sign(digest[:], privateKey) })
}

from sapphirepy import sapphirew3 = Web3(Web3.HTTPProvider('https://testnet.sapphire.oasis.dev'))
w3.middleware_onion.add(construct_sign_and_send_raw_middleware(account)from web3 import Web3
from web3.middleware import construct_sign_and_send_raw_middleware
from web3.contract.contract import Contract
from sapphirepy import sapphireaccount = Account.from_key("...")w3 = Web3(Web3.HTTPProvider('http://localhost:8545'))
w3.middleware_onion.add(
 construct_sign_and_send_raw_middleware(account)
)
w3 = sapphire.wrap(w3) # Wrapped providerdef setMessage(addr, message):
 # Wrapped MessageBox instance.
 messageBox = w3.eth.contract(address=addr, abi=abi)
 # Encrypted transaction.
 messageBox.functions.set_message(message).transact({'gasPrice': w3.eth.gas_price})