VRF Rock Paper Scissors
Connect with RISE Wallet to play
{address}
);
}
const rwConnector = connectors.find(c => c.id === "com.risechain.wallet");
if (!rwConnector) return null;
return (
);
}
```
### Sending Transactions
```tsx title="components/SendTransaction.tsx"
import { useSendCalls } from "wagmi";
import { parseEther } from "viem";
export function SendTransaction() {
const sendCalls = useSendCalls();
//for sending 0.001 ETH to some address
const handleSend = async () => {
const result = await sendCalls.mutateAsync({
calls: [{
to: "0x...",
value: parseEther("0.001"),
}],
});
console.log("Transaction sent:", result);
};
return (
);
}
```
## RISE Wallet Specific Hooks
Import custom hooks via the `Hooks` namespace:
```tsx
import { Hooks } from "rise-wallet/wagmi";
```
or individually:
```tsx
import { useGrantPermissions } from "rise-wallet/wagmi/Hooks";
```
### useGrantPermissions
Create session keys with specific permissions:
```tsx
import { parseEther } from "viem";
import { P256, PublicKey } from "ox";
const grantPermissions = Hooks.useGrantPermissions();
const createSession = async () => {
// 1. Generate a local key pair
const privateKey = P256.randomPrivateKey();
const publicKey = PublicKey.toHex(P256.getPublicKey({ privateKey }), {
includePrefix: false,
});
// 2. Grant permissions to the session key
await grantPermissions.mutateAsync({
key: { publicKey, type: "p256" },
expiry: Math.floor(Date.now() / 1000) + 3600, // 1 hour
feeToken: null, // use native token for fees, or { limit: "0.01", symbol: "ETH" }
// the permissions you want the session key to have
permissions: {
calls: [{ // function calls
to: "0x...", // address of the contract on which the function is being called
signature: "0x...", // function signature. you can get this via: cast sig "transfer(address,uint256)"
}],
// token spend limits
spend: [{
token: "0x...", // token contract address
limit: parseEther("50"), // max amount (bigint)
period: "minute", // time window (eg. "minute", "hour", "day")
}],
},
});
// 3. Store the private key to sign future transactions without popup
localStorage.setItem("session_key", privateKey);
};
```
### usePermissions
View current permissions for the connected account:
```tsx
const { data: permissions } = Hooks.usePermissions();
if (permissions) {
console.log("Active permissions:", permissions);
}
```
### useRevokePermissions
Revoke previously granted permissions:
```tsx
const revokePermissions = Hooks.useRevokePermissions();
const revokeSession = async (keyId: string) => {
await revokePermissions.mutateAsync({
keyId,
});
};
```
### useAssets
Get user's token balances and assets:
```tsx
const { data: assets } = Hooks.useAssets();
return (
{assets?.map(asset => (
);
```
## Polling Transaction Status
When using session keys with `wallet_sendPreparedCalls`, you need to manually poll for transaction status using `wallet_getCallsStatus`:
```tsx
import { P256, Signature } from "ox";
async function sendWithSessionKey(calls: any[], sessionPrivateKey: string, sessionPublicKey: string) {
const provider = await connector.getProvider();
// 1. Prepare the calls
const { digest, ...request } = await provider.request({
method: "wallet_prepareCalls",
params: [{
calls,
chainId: "0x...",
from: address,
key: { publicKey: sessionPublicKey, type: "p256" },
}],
});
// 2. Sign with session key
const signature = Signature.toHex(
P256.sign({ payload: digest, privateKey: sessionPrivateKey })
);
// 3. Send signed calls
const result = await provider.request({
method: "wallet_sendPreparedCalls",
params: [{ ...request, signature }],
});
// 4. Extract bundle ID
const bundleId = Array.isArray(result) ? result[0].id : result.id;
// 5. Poll for transaction status
const status = await provider.request({
method: "wallet_getCallsStatus",
params: [bundleId],
});
// 6. Check status
if (status.status !== 200) {
throw new Error(`Transaction failed with status ${status.status}`);
}
// 7. Return transaction hash
return status.receipts[0].transactionHash;
}
```
### Status Codes
The `status` field in the response indicates the current state of the transaction bundle:
| Code | Description |
| ---- | ------------------------------------------------------------------------------------- |
| 100 | **Pending** - Bundle received but not executed onchain yet |
| 200 | **Confirmed** - Bundle included onchain without reverts, receipts available |
| 300 | **Failed (Offchain)** - Bundle not included onchain, wallet will not retry |
| 400 | **Reverted (Complete)** - Bundle completely reverted, only gas charges may be onchain |
| 500 | **Reverted (Partial)** - Bundle partially reverted, some changes may be onchain |
### Response Structure
```ts
type GetCallsStatusResponse = {
id: string, // Bundle ID
status: number, // Status code (100-500)
receipts: {
logs: {
chainId: string,
address: string,
data: string,
topics: string[],
}[],
status: string, // "0x1" for success, "0x0" for failure
blockHash?: string,
blockNumber?: string,
gasUsed: string,
transactionHash: string, // The actual transaction hash
}[],
capabilities?: {
interopStatus?: 'pending' | 'confirmed' | 'failed',
},
}
```
{asset.symbol}: {asset.balance}
))}
sendTransactionSync() directly - it's easier but makes multiple RPC calls. Viem will soon integrate this optimization natively. See the commented code at the bottom for the simpler approach.
}
>
+{getPayout(lastWin)} RCT!
Triple {getSymbol(lastWin)} • Instant VRF Result
Session Active (Expires: {new Date(activePermission.expiry * 1000).toLocaleDateString()})
)}
```
## Testing Session Keys
Test the flow:
1. **Create Session**: Click button → One wallet popup → Key created
2. **Claim RCT**: No popup, instant transaction
3. **Spin**: No popups, completely gasless
4. **Check Permissions**: Verify in wallet or on-chain
5. **Revoke**: Remove permissions, verify spins fail
## Next Steps
Session keys are set up! Next, we'll implement event watching with Shreds to capture VRF results in real-time and build the results caching pattern for ultra-fast UX.
# Setup (/docs/cookbook/rise-slots/setup)
import { Steps, Step } from 'fumadocs-ui/components/steps';
import { Callout } from 'fumadocs-ui/components/callout';
## Project Setup
We'll build this as a monorepo combining a Foundry smart contract project with a Next.js frontend.
Connect your wallet to use passkey flow
Passkey Flow
Each transaction requires wallet approval via popup
STK Balance
{balance ? (Number(balance) / 1e18).toLocaleString() : "0"}
Counter Value
{count?.toString() || "0"}
Transaction Hash:
{txHash}Connect your wallet to use session key flow
Session Key Flow
🔑
Create a Session Key
Generate a local keypair and grant on-chain permissions for seamless transactions without popups
Session Key Flow
Session Public Key:
{PublicKey.toHex(publicKey)}
Transactions are signed locally without popups
STK Balance
{balance ? (Number(balance) / 1e18).toLocaleString() : "0"}
Counter Value
{count?.toString() || "0"}
Transaction Hash:
{txHash}RISE Wallet Quickstart
Choose a transaction signing pattern to get started
🔐
Passkey Flow
Direct transaction signing with wallet approval popups for each action
⏱️
Session Key Flow
Background signing with pre-authorized permissions for seamless UX
Connect your wallet to explore transaction flows
RISEx Trading Bot
Register to start trading via Telegram
Connected:
{address.slice(0, 6)}...{address.slice(-4)}
setTelegramId(e.target.value)}
placeholder="123456789"
className="w-full px-4 py-2 bg-gray-900 border border-gray-700 rounded-lg focus:border-purple-500 outline-none"
/>
{status && (
{status}
{sessionKey && (Session Key: {sessionKey}
)}Buy Tickets
setNumTickets(parseInt(e.target.value))}
className="w-full border rounded px-3 py-2"
/>
Total: {(0.001 * numTickets).toFixed(3)} ETH
{/* Start State */}
{gameState === 'start' && (
)}
{/* Countdown State */}
{gameState === 'countdown' && (
)}
{/* Choice State */}
{gameState === 'choice' && (
)}
{/* AI Choosing State */}
{gameState === 'ai-choosing' && (
)}
{/* Result State */}
{gameState === 'result' && (
{winner === 'player' && (
)}
Rock Paper Scissors
Play against AI powered by RISE VRF
Tickets: {tickets?.toString() || '0'}
{countdown === 3 ? '🪨' : countdown === 2 ? '📄' : '✂️'}
Get ready...
Make your choice!
AI is choosing...
🤖
{winner === 'player' ? '🎉 You Win!' : winner === 'ai' ? '😢 You Lose!' : '🤝 Tie!'}
You
{playerChoice === 'rock' ? '🪨' : playerChoice === 'paper' ? '📄' : '✂️'}VS
AI
{aiChoice === 0 ? '🪨' : aiChoice === 1 ? '📄' : '✂️'}You won 0.002 ETH!
)}**IOC (Immediate or Cancel)**: Any portion of the order that can fill immediately against resting liquidity is executed. Unfilled remainder is cancelled and doesn't rest on the book. This is non-resting and is a one-shot attempt to fill.
**GTC (Good Till Cancelled)**: Order sits on the book indefinitely until it is fully matched or there is a direct cancellation instruction. If the limit order is marketable (can be filled immediately) it will fill as much as it can and the rest remains on the book sitting as inventory.
**GTT (Good Till Time)**: Order sits on the book until user-defined expiry hits. If it doesn't match or if it only partially matches then the order is taken off the book. It is like GTC but with a user defined expiry.
**FOK (Fill or Kill)**: Entire order has to fill immediately in a single execution or the entire order is rejected and partial fills are impossible. If the book doesn't have the depth to fill then the order (at or below the limit price for limit orders, or at any price for market order) is cancelled and does not execute. | | **Take Profit / Stop Loss** | TP/SL is a conditional order triggered when the mark price reaches levels specified by the trader. These orders can be configured to fully or partially exit a position but will never change your bias.
Traders can set partial or full TP/SL positions:
**Full TP/SL**: You can only set this at once at a specific level.
**Partial TP/SL**: You can set multiple partial TP/SL orders. | # Self-Trade Prevention (/docs/risex/trading/self-trade-prevention) ## Overview RISEx implements self-trade prevention (STP) to ensure that a single account cannot match orders with itself. This prevents wash trading and maintains market integrity. *** ## How It Works When you submit an order, the matching engine checks if any resting orders on the opposite side belong to the same account. If a potential self-match is detected, the system prevents the trade from executing. *** # Take Profit / Stop Loss (/docs/risex/trading/tpsl) ## Overview Take Profit (TP) and Stop Loss (SL) orders let you automate position exits at predefined price levels. Set your risk and reward targets when entering a position, then let the system manage exits. *** ## Take Profit (TP) Automatically close your position when price reaches your profit target. ### For Long Positions * Triggers when mark price rises **above** your TP price * Closes position by selling at market ### For Short Positions * Triggers when mark price falls **below** your TP price * Closes position by buying at market *** ## Stop Loss (SL) Automatically close your position to limit losses when price moves against you. ### For Long Positions * Triggers when mark price falls **below** your SL price * Closes position by selling at market ### For Short Positions * Triggers when mark price rises **above** your SL price * Closes position by buying at market *** ## Setting TP/SL You can set TP/SL orders: 1. **When opening a position**: Set TP/SL as part of your entry order 2. **On existing positions**: Add TP/SL to positions you already hold 3. **Modify anytime**: Update TP/SL levels while the position is open *** ## Execution TP/SL orders execute as **market orders** when triggered. This ensures execution but may result in slippage during volatile conditions. *** ## Partial TP/SL You can set TP/SL for a portion of your position: * Take partial profits at multiple levels * Scale out of positions gradually * Keep exposure while locking in gains *** ## Important Considerations ### Trigger Price TP/SL orders trigger based on the **mark price**, not the last traded price. This prevents manipulation via single trades. ### Cancellation TP/SL orders are automatically cancelled when: * The associated position is fully closed * You manually cancel them * The position is liquidated # Get Started with Ethers.js (/docs/builders/frontend/ethers/get-started) Learn how to set up and configure Ethers.js for building on RISE. ## Installation Install Ethers.js v6 using your preferred package manager: ```bash npm install ethers ``` ## Project Setup Create a new project: ```bash mkdir my-rise-ethers-project cd my-rise-ethers-project npm init -y npm install ethers dotenv ``` ## Connect to RISE ### Using JsonRpcProvider Connect to RISE Testnet: ```javascript import { ethers } from 'ethers'; const provider = new ethers.JsonRpcProvider('https://testnet.riselabs.xyz'); // Get network info const network = await provider.getNetwork(); console.log('Connected to:', network.name); console.log('Chain ID:', network.chainId); // Get latest block const blockNumber = await provider.getBlockNumber(); console.log('Latest block:', blockNumber); ``` ### Create a Wallet Create a wallet from a private key: ```javascript import { ethers } from 'ethers'; const provider = new ethers.JsonRpcProvider('https://testnet.riselabs.xyz'); // From private key const wallet = new ethers.Wallet( 'YOUR_PRIVATE_KEY', provider ); console.log('Address:', wallet.address); // Get balance const balance = await provider.getBalance(wallet.address); console.log('Balance:', ethers.formatEther(balance), 'ETH'); ``` ### Generate New Wallet Create a new random wallet: ```javascript // Generate new wallet const newWallet = ethers.Wallet.createRandom(); console.log('Address:', newWallet.address); console.log('Private Key:', newWallet.privateKey); console.log('Mnemonic:', newWallet.mnemonic.phrase); // Connect to provider const connectedWallet = newWallet.connect(provider); ``` ### From Mnemonic Restore wallet from mnemonic phrase: ```javascript const mnemonic = 'your twelve word mnemonic phrase here ...'; const wallet = ethers.Wallet.fromPhrase(mnemonic, provider); console.log('Address:', wallet.address); ``` ## Environment Variables Create a `.env` file: ```bash PRIVATE_KEY=0x... RPC_URL=https://testnet.riselabs.xyz ``` Load and use environment variables: ```javascript import { ethers } from 'ethers'; import { config } from 'dotenv'; config(); const provider = new ethers.JsonRpcProvider(process.env.RPC_URL); const wallet = new ethers.Wallet(process.env.PRIVATE_KEY, provider); console.log('Connected as:', wallet.address); ``` ## Network Configuration Create a config file for RISE network: ```javascript // config.js export const RISE_TESTNET = { chainId: 11155931, name: 'RISE Testnet', rpcUrl: 'https://testnet.riselabs.xyz', explorer: 'https://explorer.testnet.riselabs.xyz', symbol: 'ETH', decimals: 18 }; export function getProvider() { return new ethers.JsonRpcProvider(RISE_TESTNET.rpcUrl); } export function getWallet(privateKey) { const provider = getProvider(); return new ethers.Wallet(privateKey, provider); } ``` Usage: ```javascript import { getProvider, getWallet } from './config.js'; const provider = getProvider(); const wallet = getWallet(process.env.PRIVATE_KEY); ``` ## Basic Operations ### Check Account Balance ```javascript const address = '0x...'; const balance = await provider.getBalance(address); console.log('Balance (wei):', balance.toString()); console.log('Balance (ETH):', ethers.formatEther(balance)); ``` ### Get Transaction Count (Nonce) ```javascript const nonce = await provider.getTransactionCount(wallet.address); console.log('Transaction count:', nonce); ``` ### Get Gas Price ```javascript const feeData = await provider.getFeeData(); console.log('Gas Price:', ethers.formatUnits(feeData.gasPrice, 'gwei'), 'Gwei'); console.log('Max Fee:', ethers.formatUnits(feeData.maxFeePerGas, 'gwei'), 'Gwei'); console.log('Max Priority Fee:', ethers.formatUnits(feeData.maxPriorityFeePerGas, 'gwei'), 'Gwei'); ``` ### Send ETH ```javascript const tx = await wallet.sendTransaction({ to: '0x...', value: ethers.parseEther('0.1') // 0.1 ETH }); console.log('Transaction hash:', tx.hash); // Wait for confirmation const receipt = await tx.wait(); console.log('Transaction confirmed in block:', receipt.blockNumber); ``` ## Example: Complete Setup ```javascript // index.js import { ethers } from 'ethers'; import { config } from 'dotenv'; config(); // Setup const provider = new ethers.JsonRpcProvider('https://testnet.riselabs.xyz'); const wallet = new ethers.Wallet(process.env.PRIVATE_KEY, provider); async function main() { // Network info const network = await provider.getNetwork(); console.log('Network:', network.name); console.log('Chain ID:', network.chainId.toString()); // Account info console.log('\nAccount:', wallet.address); const balance = await provider.getBalance(wallet.address); console.log('Balance:', ethers.formatEther(balance), 'ETH'); const nonce = await provider.getTransactionCount(wallet.address); console.log('Nonce:', nonce); // Block info const blockNumber = await provider.getBlockNumber(); console.log('\nLatest block:', blockNumber); const block = await provider.getBlock('latest'); console.log('Block timestamp:', new Date(block.timestamp * 1000).toISOString()); // Gas info const feeData = await provider.getFeeData(); console.log('\nGas Price:', ethers.formatUnits(feeData.gasPrice, 'gwei'), 'Gwei'); } main().catch(console.error); ``` Run the script: ```bash node index.js ``` ## Next Steps * [Reading from Contracts](/docs/builders/ethers/reading) - Query contract data * [Writing to Contracts](/docs/builders/ethers/writing) - Send transactions and interact with contracts # Ethers.js (/docs/builders/frontend/ethers) Ethers.js is a complete and compact library for interacting with the Ethereum blockchain and its ecosystem. It's widely used and battle-tested. ## Why Ethers.js? * **Complete**: Full-featured library with everything you need * **Well-documented**: Extensive documentation and examples * **Stable**: Mature and battle-tested in production * **Popular**: Large community and ecosystem support * **Easy to learn**: Intuitive API design ## Quick Start ```bash npm install ethers ``` ## Basic Setup ```javascript import { ethers } from 'ethers'; // Connect to RISE Testnet const provider = new ethers.JsonRpcProvider('https://testnet.riselabs.xyz'); // Get the latest block number const blockNumber = await provider.getBlockNumber(); console.log('Current block:', blockNumber); // Create a wallet const wallet = new ethers.Wallet(privateKey, provider); console.log('Wallet address:', wallet.address); // Get balance const balance = await provider.getBalance(wallet.address); console.log('Balance:', ethers.formatEther(balance), 'ETH'); ``` ## Network Configuration ```javascript const RISE_TESTNET = { chainId: 11155931, name: 'RISE Testnet', rpcUrl: 'https://testnet.riselabs.xyz', explorer: 'https://explorer.testnet.riselabs.xyz' }; ``` ## Next Steps