All Items with Durability 2:
{Object.entries(items).map(([id, item]) => (
Item {id}: durability {item?.durability}
))}
Single Item:
{item &&
Item 1: durability {item.durability}
}
);
}
```
##### Option 2: Direct Zustand Store Access
For more advanced use cases, you can access the Zustand store directly:
```typescript
import { useDojoSDK, useEntityQuery } from "@dojoengine/sdk/react";
function MyComponent() {
const { useDojoStore } = useDojoSDK(); // The Zustand store
// Subscribe to entity changes
useEntityQuery(
new ToriiQueryBuilder()
.withClause(MemberClause("dojo_starter-Item", "durability", "Eq", 2).build())
.includeHashedKeys()
);
// Access the raw store
const allEntities = useDojoStore((state) =>
state.entities
);
const itemEntities = useDojoStore((state) =>
state.getEntitiesByModel("dojo_starter", "Item")
);
return (
Total entities in store: {Object.keys(allEntities).length}
Item entities: {itemEntities.length}
{itemEntities.map((entity) => {
const item = entity.models.dojo_starter.Item;
return (
Entity {entity.entityId}: durability {item?.durability}
);
})}
);
}
```
#### Sending Signed Messages
Signed messages allow you to send **authenticated off-chain data** to Torii without expensive blockchain transactions.
This can be used to implement things like **chat systems, leaderboards, social features, game coordination, and real-time events.**
The key benefit: **Players authenticate the data** (proving it came from them) **without gas fees**, while Torii broadcasts it to all connected clients in real-time.
Here's an example of how to send a signed message:
```typescript
// Generate typed data for a chat message model
const typedData = sdk.generateTypedData("world-Message", {
identity: account?.address,
content: messageContent,
timestamp: Date.now(),
});
try {
// Sign and send the message using the SDK
const result = await sdk.sendMessage(typedData, account);
if (result.isOk()) {
console.log("Message sent successfully:", result.value);
} else {
console.error("Failed to send message:", result.error);
}
} catch (error) {
console.error("Error sending message:", error);
}
```
:::note
If you want messages to be broadcast to all of your Torii client instances, you'll have to pass a `relayUrl` to `init`.
`relayUrl` is a *multiaddr* format which looks like something like this when deployed on slot:
`/dns4/api.cartridge.gg/tcp/443/x-parity-wss/%2Fx%2Fyour-slot-deployment-name%2Ftorii%2Fwss`
:::
#### Querying Tokens
dojo.js can query token data (ERC20, ERC721, ERC1155) indexed by Torii.
First, configure Torii to index your tokens:
```toml
# dojo_dev.toml
[indexing]
contracts = [
"erc20:0x49d36570d4e46f48e99674bd3fcc84644ddd6b96f7c741b1562b82f9e004dc7", # ETH
"erc20:0x4718f5a0fc34cc1af16a1cdee98ffb20c31f5cd61d6ab07201858f4287c938d", # STRK
"erc721:0x..." # Your NFT contract
]
```
Then query token balances in your React components:
```typescript
import { useTokens } from "@dojoengine/sdk/react";
function TokenBalance({ address }: { address: string }) {
const { tokens, balances, getBalance, toDecimal } = useTokens({
accountAddresses: [address],
});
return (
Token Balances for {address}
{tokens.map((token, idx) => (
{token.symbol}: {toDecimal(token, getBalance(token))}
))}
);
}
```
#### Optimistic Client Rendering
We use [immer](https://immerjs.github.io/immer/) for efficient optimistic rendering.
This allows instant client-side entity state updates while awaiting blockchain confirmation.
**The process:**
1. Update entity state optimistically.
2. Wait for condition (e.g., a specific state change).
3. Resolve update, providing immediate user feedback.
This ensures a responsive user experience while maintaining blockchain data integrity.
:::note
You will need to have a subscription running in order for the update to resolve.
:::
```typescript
import { useCallback } from "react";
import { v4 as uuidv4 } from "uuid";
import { useDojoSDK } from "@dojoengine/sdk/react";
import { useAccount } from "@starknet-react/core";
import { getEntityIdFromKeys } from "@dojoengine/utils";
export function useSystemCalls(entityId: string) {
const { account } = useAccount();
const { useDojoStore, client } = useDojoSDK();
const state = useDojoStore((s) => s);
const spawn = useCallback(async () => {
if (!account) return;
// Generate a unique transaction ID
const transactionId = uuidv4();
// The value to update the Moves model with
const remainingMoves = 100;
// Apply an optimistic update to the state
// this uses immer drafts to update the state
state.applyOptimisticUpdate(transactionId, (draft) => {
if (draft.entities[entityId]?.models?.dojo_starter?.Moves) {
draft.entities[entityId].models.dojo_starter.Moves!.remaining =
remainingMoves;
}
});
try {
// Execute the spawn action
await client.actions.spawn({ account });
// Wait for the entity to be updated with the new state
await state.waitForEntityChange(entityId, (entity) => {
return (
entity?.models?.dojo_starter?.Moves?.remaining ===
remainingMoves
);
});
} catch (error) {
// Revert the optimistic update if an error occurs
state.revertOptimisticUpdate(transactionId);
console.error("Error executing spawn:", error);
throw error;
} finally {
// Confirm the transaction if successful
state.confirmTransaction(transactionId);
}
}, [account, client, entityId, state]);
return { spawn };
}
```
### Additional Examples
See this [example project](https://github.com/dojoengine/dojo.js/tree/main/examples/example-vite-react-sdk) for a real-world implementation.
## Dojo Rust SDK
Dojo is built in Rust, making it seamless to integrate into your Rust projects.
Simply import the required crates and you're ready to build powerful applications that interact with Dojo worlds.
The Dojo Rust SDK provides access to the core framework functionality, built on the same [dojo.c foundation](/client/sdk/c) that powers other language bindings.
### Core Components
The Dojo Rust ecosystem provides several key crates for different use cases:
* **`dojo-types`**: Core types and data structures for Dojo
* **`dojo-world`**: World contract interaction and management
* **`torii-client`**: Client for connecting to Torii indexer
* **`torii-grpc`**: gRPC client for real-time data streaming
* **`torii-relay`**: P2P networking and relay functionality
* **`cainome`**: Contract bindings generation for Cairo contracts
### Getting Started
Add these dependencies to your `Cargo.toml`:
```toml
[dependencies]
# Core Dojo types and functionality
dojo-types = { git = "https://github.com/dojoengine/dojo", tag = "v1.7.0-alpha.0" }
dojo-world = { git = "https://github.com/dojoengine/dojo", tag = "v1.7.0-alpha.0" }
# Torii client for indexing and real-time data (separate repository since 1.5.0)
torii-client = { git = "https://github.com/dojoengine/torii", tag = "v1.6.1-preview.2" }
torii-grpc-client = { git = "https://github.com/dojoengine/torii", tag = "v1.6.1-preview.2" }
# Contract bindings generation
cainome = { git = "https://github.com/cartridge-gg/cainome", rev = "7d60de1", features = ["abigen-rs"] }
cainome-cairo-serde = { git = "https://github.com/cartridge-gg/cainome", rev = "7d60de1" }
# Starknet integration
starknet = "0.17.0-rc.2"
starknet-crypto = "0.7.4"
starknet-types-core = "0.1.7"
# Async runtime
tokio = { version = "1.39", features = ["full"] }
```
### Basic Usage
#### Connecting to a Dojo World
```rust
// Import necessary types for connecting to Dojo
use torii_client::client::Client;
use starknet_crypto::Felt;
// The #[tokio::main] attribute makes this function run in an async runtime
// This is required because we'll be making network calls
#[tokio::main]
async fn main() -> Result<(), Box
