Zama Confidential Blockchain Protocol

https://docs.zama.org/
Admin
The docs aim to guide you to build confidential dApps using Fully Homomorphic Encryption (FHE).
Tokens:283,414
Snippets:2,844
Trust Score:8.7
Update:3 months ago
Show doc for...
Tokens:
Raw
### Querying Documentation Example

Source: https://docs.zama.org/protocol/sdk/api-references/sdk/genericprovider.md

Example of how to dynamically query documentation by making an HTTP GET request with 'ask' and optional 'goal' query parameters.

```http
GET https://docs.zama.org/protocol/sdk/api-references/sdk/genericprovider.md?ask=<question>&goal=<endgoal>
```

--------------------------------

### Start Development Server

Source: https://docs.zama.org/protocol/sdk/getting-started/first-confidential-dapp.md

Command to start the development server for your DApp. Ensure you have pnpm installed and the project dependencies are set up.

```bash
pnpm dev
```

--------------------------------

### Example GET Request for Documentation Query

Source: https://docs.zama.org/protocol/sdk/api-references/react/usewrappersregistryaddress.md

Demonstrates how to query the documentation dynamically using an HTTP GET request. This is useful for retrieving information not explicitly present on the page or for clarification.

```http
GET https://docs.zama.org/protocol/sdk/api-references/react/usewrappersRegistryaddress.md?ask=<question>&goal=<endgoal>
```

--------------------------------

### Query Documentation Example

Source: https://docs.zama.org/protocol/sdk/guides/shield-tokens.md

Use this GET request to query the documentation dynamically. Replace `<question>` with your specific query and `<endgoal>` with your broader objective.

```http
GET https://docs.zama.org/protocol/sdk/guides/shield-tokens.md?ask=<question>&goal=<endgoal>
```

--------------------------------

### Query Documentation Example

Source: https://docs.zama.org/protocol/examples/basic/decryption/fhe-user-decrypt-multiple-values.md

Demonstrates how to perform an HTTP GET request to query documentation dynamically. Use the 'ask' parameter for specific questions and the optional 'goal' parameter for broader context.

```http
GET https://docs.zama.org/protocol/examples/basic/decryption/fhe-user-decrypt-multiple-values.md?ask=<question>&goal=<endgoal>
```

--------------------------------

### Compile and Run Tests

Source: https://docs.zama.org/protocol/solidity-guides/getting-started/setup-1.md

Build the project and run tests to verify the setup. This step ensures that the example FHECounter contract tests pass.

```bash
forge build
forge test -vvv
```

--------------------------------

### Example GET Request for Documentation Query

Source: https://docs.zama.org/protocol/examples/basic/decryption/fhe-user-decrypt-single-value.md

Use this endpoint to ask questions about the documentation. The 'ask' parameter specifies the question, and 'goal' provides optional broader context for the AI.

```http
GET https://docs.zama.org/protocol/examples/basic/decryption/fhe-user-decrypt-single-value.md?ask=<question>&goal=<endgoal>
```

--------------------------------

### Query Documentation Dynamically

Source: https://docs.zama.org/protocol/protocol-apps/confidential-tokens/wrapper-registry.md

This example shows how to make an HTTP GET request to query the documentation. Use the 'ask' parameter for your question and optionally the 'goal' parameter for your broader objective.

```http
GET https://docs.zama.org/protocol/protocol-apps/confidential-tokens/wrapper-registry.md?ask=<question>&goal=<endgoal>
```

--------------------------------

### Install Zama SDK Packages

Source: https://docs.zama.org/protocol/sdk/guides/local-development.md

Install the necessary Zama SDK packages and Viem for local development.

```bash
npm install @zama-fhe/sdk viem
```

--------------------------------

### Install Vanilla SDK

Source: https://docs.zama.org/protocol/sdk/overview.md

Use this command to install the core SDK for vanilla TypeScript or Node.js applications.

```sh
# Vanilla TypeScript / Node.js
pnpm add @zama-fhe/sdk
```

--------------------------------

### Install Vanilla SDK (npm)

Source: https://docs.zama.org/protocol/sdk/overview.md

Use this command to install the core SDK for vanilla TypeScript or Node.js applications using npm.

```sh
# Vanilla TypeScript / Node.js
npm install @zama-fhe/sdk
```

--------------------------------

### Install Zama SDK for ethers

Source: https://docs.zama.org/protocol/sdk/getting-started/quick-start.md

Install the Zama SDK and ethers.js for your project.

```bash
pnpm add @zama-fhe/sdk ethers
```

--------------------------------

### Install React SDK with Dependencies

Source: https://docs.zama.org/protocol/sdk/overview.md

Use this command to install the React SDK along with its core SDK and React query dependency for React applications.

```sh
# React app
pnpm add @zama-fhe/react-sdk @zama-fhe/sdk @tanstack/react-query
```

--------------------------------

### Install Zama SDK and Dependencies

Source: https://docs.zama.org/protocol/sdk/getting-started/first-confidential-dapp.md

Install the necessary Zama SDK packages, React SDK, and other project dependencies using pnpm.

```bash
pnpm add @zama-fhe/sdk @zama-fhe/react-sdk @tanstack/react-query wagmi viem
```

--------------------------------

### Install Project Dependencies

Source: https://docs.zama.org/protocol/examples/openzeppelin-confidential-contracts/openzeppelin.md

Install all necessary project dependencies using npm ci for a clean installation.

```bash
npm ci
```

--------------------------------

### Querying Documentation via HTTP GET

Source: https://docs.zama.org/protocol/examples/basic/encryption/fhe-encrypt-multiple-values.md

Demonstrates the HTTP GET request format for querying documentation. Use the 'ask' parameter for specific questions and the optional 'goal' parameter for broader context.

```bash
GET https://docs.zama.org/protocol/examples/basic/encryption/fhe-encrypt-multiple-values.md?ask=<question>&goal=<endgoal>
```

--------------------------------

### Install OpenZeppelin Confidential Contracts

Source: https://docs.zama.org/protocol/examples/openzeppelin-confidential-contracts/openzeppelin.md

Install OpenZeppelin's confidential contracts library as a project dependency.

```bash
npm i @openzeppelin/confidential-contracts
```

--------------------------------

### Instantiate ViemProvider

Source: https://docs.zama.org/protocol/sdk/api-references/sdk/viemprovider.md

Example of how to instantiate ViemProvider with a viem PublicClient.

```APIDOC
## Usage

```ts
import { createPublicClient, http } from "viem";
import { sepolia } from "viem/chains";
import { ViemProvider } from "@zama-fhe/sdk/viem";

const publicClient = createPublicClient({
  chain: sepolia,
  transport: http("https://sepolia.infura.io/v3/YOUR_KEY"),
});

const provider = new ViemProvider({ publicClient });
```

{% hint style="info" %}
You rarely need to instantiate `ViemProvider` directly. The viem `createConfig` builds one from the `publicClient` you pass. Use this class when constructing `ZamaSDK` manually or when using the generic `createConfig`.{% endhint %}
```

--------------------------------

### Install Vanilla SDK (yarn)

Source: https://docs.zama.org/protocol/sdk/overview.md

Use this command to install the core SDK for vanilla TypeScript or Node.js applications using yarn.

```sh
# Vanilla TypeScript / Node.js
yarn add @zama-fhe/sdk
```

--------------------------------

### Custom Provider Implementation Example

Source: https://docs.zama.org/protocol/sdk/api-references/sdk/genericprovider.md

An example class demonstrating how to implement the `GenericProvider` interface for a custom blockchain provider.

```typescript
import type { GenericProvider } from "@zama-fhe/sdk";

class MyProvider implements GenericProvider {
  async getChainId() {
    /* ... */
  }
  async readContract(config) {
    /* ... */
  }
  async waitForTransactionReceipt(hash) {
    /* ... */
  }
  async getBlockTimestamp() {
    /* ... */
  }
}
```

--------------------------------

### Example Configuration for useDelegationStatus

Source: https://docs.zama.org/protocol/sdk/api-references/react/usedelegationstatus.md

Provides an example of how to configure the useDelegationStatus hook with contract and address details.

```typescript
const { data } = useDelegationStatus({
  contractAddress: "0xToken",
  delegatorAddress: "0xDelegator",
  delegateAddress: "0xDelegate",
});
```

--------------------------------

### Install React SDK with Dependencies (npm)

Source: https://docs.zama.org/protocol/sdk/overview.md

Use this command to install the React SDK along with its core SDK and React query dependency for React applications using npm.

```sh
# React app
npm install @zama-fhe/react-sdk @zama-fhe/sdk @tanstack/react-query
```

--------------------------------

### Usage Examples

Source: https://docs.zama.org/protocol/sdk/api-references/react/query-keys.md

Examples demonstrating how to use zamaQueryKeys with React Query's useQueryClient to invalidate cache entries.

```APIDOC
## Usage

```tsx
import { useQueryClient } from "@tanstack/react-query";
import { zamaQueryKeys } from "@zama-fhe/sdk/query";

const queryClient = useQueryClient();

// Invalidate all balances
queryClient.invalidateQueries({ queryKey: zamaQueryKeys.confidentialBalance.all });

// Invalidate one token's balances
queryClient.invalidateQueries({
  queryKey: zamaQueryKeys.confidentialBalance.token("0xToken"),
});

// Invalidate a specific owner's balance
queryClient.invalidateQueries({
  queryKey: zamaQueryKeys.confidentialBalance.owner("0xToken", "0xOwner"),
});
```
```

--------------------------------

### Querying Documentation with HTTP GET

Source: https://docs.zama.org/protocol/sdk/getting-started

Use this HTTP GET request to query the documentation dynamically. Include an 'ask' parameter for your specific question and an optional 'goal' parameter to tailor the response.

```http
GET https://docs.zama.org/protocol/sdk/getting-started.md?ask=<question>&goal=<endgoal>
```

--------------------------------

### Import zamaQueryKeys

Source: https://docs.zama.org/protocol/sdk/api-references/react/query-keys.md

Import the zamaQueryKeys factory from the SDK to start using it.

```APIDOC
## Import

```ts
import { zamaQueryKeys } from "@zama-fhe/sdk/query";
```
```

--------------------------------

### Viem Setup with ZamaProvider

Source: https://docs.zama.org/protocol/sdk/api-references/react/zamaprovider.md

Configure and wrap your application with ZamaProvider when using viem for blockchain interactions. This setup involves creating viem clients and configuring the Zama SDK with appropriate chains and relayers.

```typescript
import { createPublicClient, createWalletClient, custom, http } from "viem";
import { sepolia } from "viem/chains";
import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
import { ZamaProvider } from "@zama-fhe/react-sdk";
import { web } from "@zama-fhe/sdk/web";
import { createConfig } from "@zama-fhe/sdk/viem";
import { sepolia as sepoliaFhe, type FheChain } from "@zama-fhe/sdk/chains";

const publicClient = createPublicClient({
  chain: sepolia,
  transport: http("https://sepolia.infura.io/v3/YOUR_KEY"),
});
const walletClient = createWalletClient({
  chain: sepolia,
  transport: custom(window.ethereum!),
});

const mySepolia = {
  ...sepoliaFhe,
  relayerUrl: "https://your-app.com/api/relayer/11155111",
} as const satisfies FheChain;

const zamaConfig = createConfig({
  chains: [mySepolia],
  publicClient,
  walletClient,
  relayers: {
    [mySepolia.id]: web(),
  },
});
const queryClient = new QueryClient();

function App() {
  return (
    <QueryClientProvider client={queryClient}>
      <ZamaProvider config={zamaConfig}>
        <YourApp />
      </ZamaProvider>
    </QueryClientProvider>
  );
}
```

--------------------------------

### Query Documentation with GET Request

Source: https://docs.zama.org/homepage/llms.txt

Use this GET request to query the documentation index with an 'ask' parameter for specific questions and an optional 'goal' parameter for broader context. The response includes a direct answer and relevant excerpts.

```http
GET https://docs.zama.org/homepage/readme.md?ask=<question>&goal=<end_goal>
```

--------------------------------

### Query Documentation

Source: https://docs.zama.org/protocol/examples/basic/encryption.md

Demonstrates how to query the documentation dynamically using HTTP GET requests. Use this to get information not explicitly present on the page or to retrieve related documentation.

```http
GET https://docs.zama.org/protocol/examples/basic/encryption.md?ask=<question>&goal=<endgoal>
```

--------------------------------

### Install Zama Skills for Claude

Source: https://docs.zama.org/protocol/sdk/getting-started/build-with-an-llm.md

Use these commands to install the Zama skills for Claude. This provides your agent with expert, up-to-date guidance on the protocol and SDK.

```bash
/plugin marketplace add zama-ai/skills
/plugin install zama-protocol@zama-skills
```

--------------------------------

### Install Zama SDK v3 Dependencies

Source: https://docs.zama.org/protocol/sdk/migration/migrate-v2-to-v3.md

Install the latest versions of the core SDK and the React SDK. The React SDK depends on the core SDK.

```bash
pnpm add @zama-fhe/sdk@^3 @zama-fhe/react-sdk@^3
```

--------------------------------

### Install React SDK with Dependencies (yarn)

Source: https://docs.zama.org/protocol/sdk/overview.md

Use this command to install the React SDK along with its core SDK and React query dependency for React applications using yarn.

```sh
# React app
yarn add @zama-fhe/react-sdk @zama-fhe/sdk @tanstack/react-query
```

--------------------------------

### App Setup with Providers

Source: https://docs.zama.org/protocol/sdk/getting-started/first-confidential-dapp.md

Wrap your application in Wagmi, React Query, and Zama providers. The Zama provider requires a configuration derived from your wagmi setup to automatically manage FHE operations.

```tsx
import { WagmiProvider } from "wagmi";
import { QueryClientProvider } from "@tanstack/react-query";
import { ZamaProvider } from "@zama-fhe/react-sdk";
import { wagmiConfig, queryClient, zamaConfig } from "./config";
import { Dashboard } from "./Dashboard";

export default function App() {
  return (
    <WagmiProvider config={wagmiConfig}>
      <QueryClientProvider client={queryClient}>
        <ZamaProvider config={zamaConfig}>
          <h1>Confidential Token Dashboard</h1>
          <Dashboard />
        </ZamaProvider>
      </QueryClientProvider>
    </WagmiProvider>
  );
}
```

--------------------------------

### Query Documentation with GET Request

Source: https://docs.zama.org/protocol/solidity-guides/getting-started

You can query this documentation dynamically by performing an HTTP GET request to the current page URL with the `ask` query parameter and an optional `goal` parameter. This is useful for retrieving specific information or context not immediately apparent on the page.

```http
GET https://docs.zama.org/protocol/solidity-guides/getting-started.md?ask=<question>&goal=<endgoal>
```

--------------------------------

### useWrapperDiscovery Hook Usage

Source: https://docs.zama.org/protocol/sdk/api-references/react/usewrapperdiscovery.md

Example of how to use the useWrapperDiscovery hook to get the wrapper address for a token.

```APIDOC
## useWrapperDiscovery

### Description
Find the confidential wrapper contract address for an ERC-20 token via the on-chain registry. The result is cached indefinitely since wrapper addresses never change.

### Import
```ts
import { useWrapperDiscovery } from "@zama-fhe/react-sdk";
```

### Parameters
#### tokenAddress
`Address`

Address of any confidential token you control. Used to scope the query cache key and to gate whether the query is enabled — it does not affect which wrapper the registry returns.

#### erc20Address
`Address | undefined`

Address of the ERC-20 token to discover the wrapper for. Pass `undefined` to disable the query.

### Return Type
The `data` field resolves to `Address | null` -- the wrapper contract address for the given token, or `null` if no wrapper exists.

### Caching
The query uses `staleTime: Infinity`. Wrapper addresses are immutable once deployed, so the result never re-fetches automatically.

### Suspense
Use `useWrapperDiscoverySuspense` inside a `<Suspense>` boundary to avoid manual loading state handling:

```tsx
import { useWrapperDiscoverySuspense } from "@zama-fhe/react-sdk";

function WrapperInfo({ tokenAddress }: { tokenAddress: `0x${string}` }) {
  const { data: wrapperAddress } = useWrapperDiscoverySuspense({
    tokenAddress,
    erc20Address: "0xUSDC",
  });

  return <p>Wrapper: {wrapperAddress}</p>;
}
```
```

--------------------------------

### HighestDieRoll Game Contract Interaction

Source: https://docs.zama.org/protocol/examples/basic/decryption/highest-die-roll.md

This snippet shows the setup and execution of a Highest Die Roll game, including contract deployment, player setup, and starting a new game. It also includes a helper function to parse the `GameCreated` event.

```typescript
import { expect } from "chai";
import { ethers } from "hardhat";
import { Signers, HighestDieRoll } from "../typechain-types";
import { deployFixture } from "./fixtures/deploy";
import { HardhatEthersSigner } from "@nomicfoundation/hardhat-ethers/signers";
import { EthersT } from "ethers";

// Mock type for ClearValueType for demonstration purposes
type ClearValueType = bigint;

describe("HighestDieRoll", function () {
  let contract: HighestDieRoll;
  let contractAddress: string;
  let signers: Signers;
  let playerA: HardhatEthersSigner;
  let playerB: HardhatEthersSigner;

  before(async function () {
    // Check whether the tests are running against an FHEVM mock environment
    if (!hre.fhevm.isMock) {
      throw new Error(`This hardhat test suite cannot run on Sepolia Testnet`);
    }

    const ethSigners: HardhatEthersSigner[] = await ethers.getSigners();
    signers = { owner: ethSigners[0], alice: ethSigners[1], bob: ethSigners[2] };

    playerA = signers.alice;
    playerB = signers.bob;
  });

  beforeEach(async function () {
    // Deploy a new contract each time we run a new test
    const deployment = await deployFixture();
    contractAddress = deployment.highestDiceRoll_address;
    contract = deployment.highestDiceRoll;
  });

  /**
   * Helper: Parses the GameCreated event from a transaction receipt.
   * WARNING: This function is for illustrative purposes only and is not production-ready
   * (it does not handle several events in same tx).
   */
  function parseGameCreatedEvent(txReceipt: EthersT.ContractTransactionReceipt | null): {
    txHash: `0x${string}`;
    gameId: number;
    playerA: `0x${string}`;
    playerB: `0x${string}`;
    playerAEncryptedDiceRoll: `0x${string}`;
    playerBEncryptedDiceRoll: `0x${string}`;
  } {
    const gameCreatedEvents: Array<{ 
      txHash: `0x${string}`;
      gameId: number;
      playerA: `0x${string}`;
      playerB: `0x${string}`;
      playerAEncryptedDiceRoll: `0x${string}`;
      playerBEncryptedDiceRoll: `0x${string}`;
    }> = [];

    if (txReceipt) {
      const logs = Array.isArray(txReceipt.logs) ? txReceipt.logs : [txReceipt.logs];
      for (let i = 0; i < logs.length; ++i) {
        const parsedLog = contract.interface.parseLog(logs[i]);
        if (!parsedLog || parsedLog.name !== "GameCreated") {
          continue;
        }
        const ge = {
          txHash: txReceipt.hash as `0x${string}`,
          gameId: Number(parsedLog.args[0]),
          playerA: parsedLog.args[1],
          playerB: parsedLog.args[2],
          playerAEncryptedDiceRoll: parsedLog.args[3],
          playerBEncryptedDiceRoll: parsedLog.args[4],
        };
        gameCreatedEvents.push(ge);
      }
    }

    // In this example, we expect on one single GameCreated event
    expect(gameCreatedEvents.length).to.eq(1);

    return gameCreatedEvents[0];
  }

  // ✅ Test should succeed
  it("decryption should succeed", async function () {
    console.log(``);
    console.log(`🎲 HighestDieRoll Game contract address: ${contractAddress}`);
    console.log(`   🤖 playerA.address: ${playerA.address}`);
    console.log(`   🎃 playerB.address: ${playerB.address}`);
    console.log(``);

    // Starts a new Heads or Tails game. This will emit a `GameCreated` event
    const tx = await contract.connect(signers.owner).highestDieRoll(playerA, playerB);

    // Parse the `GameCreated` event
    const gameCreatedEvent = parseGameCreatedEvent(await tx.wait())!;

    // GameId is 1 since we are playing the first game
    expect(gameCreatedEvent.gameId).to.eq(1);
    expect(gameCreatedEvent.playerA).to.eq(playerA.address);
    expect(gameCreatedEvent.playerB).to.eq(playerB.address);
    expect(await contract.getGamesCount()).to.eq(1);

    console.log(`✅ New game #${gameCreatedEvent.gameId} created!`);
    console.log(JSON.stringify(gameCreatedEvent, null, 2));

    const gameId = gameCreatedEvent.gameId;
    const playerADiceRoll = gameCreatedEvent.playerAEncryptedDiceRoll;
    const playerBDiceRoll = gameCreatedEvent.playerBEncryptedDiceRoll;

    // Call the Zama Relayer to compute the decryption
    const publicDecryptResults = await fhevm.publicDecrypt([playerADiceRoll, playerBDiceRoll]);

    // The Relayer returns a `PublicDecryptResults` object containing:
    // - the ORDERED clear values (here we have only one single value)
    // - the ORDERED clear values in ABI-encoded form
    // - the KMS decryption proof associated with the ORDERED clear values in ABI-encoded form
    const abiEncodedClearGameResult = publicDecryptResults.abiEncodedClearValues;
    const decryptionProof = publicDecryptResults.decryptionProof;

    const clearValueA: ClearValueType = publicDecryptResults.clearValues[playerADiceRoll];
    const clearValueB: ClearValueType = publicDecryptResults.clearValues[playerBDiceRoll];

    expect(typeof clearValueA).to.eq("bigint");
    expect(typeof clearValueB).to.eq("bigint");

    // playerA's 8-sided die roll result (between 1 and 8)
    const a = (Number(clearValueA) % 8) + 1;
    // playerB's 8-sided die roll result (between 1 and 8)
    const b = (Number(clearValueB) % 8) + 1;

    const isDraw = a === b;
    const playerAWon = a > b;
    const playerBWon = a < b;
  });
});

```

--------------------------------

### Get Current Fee Basis Points

Source: https://docs.zama.org/protocol/protocol-apps/staking.md

Retrieves the current commission fee percentage in basis points. For example, 1000 represents 10%.

```solidity
// Returns the current fee in basis points (e.g., 1000 = 10%)
uint16 currentFee = operatorRewarder.feeBasisPoints();
```

--------------------------------

### Set up Zama SDK with viem

Source: https://docs.zama.org/protocol/sdk/getting-started/quick-start.md

Configure the Zama SDK for use with viem, including setting up public and wallet clients. Replace placeholder values like YOUR_KEY and your-app.com.

```ts
import { createPublicClient, createWalletClient, custom, http } from "viem";
import { sepolia } from "viem/chains";
import { createConfig } from "@zama-fhe/sdk/viem";
import { ZamaSDK } from "@zama-fhe/sdk";
import { web } from "@zama-fhe/sdk/web";
import { sepolia as sepoliaFhe, type FheChain } from "@zama-fhe/sdk/chains";

const publicClient = createPublicClient({
  chain: sepolia,
  transport: http("https://sepolia.infura.io/v3/YOUR_KEY"),
});
const walletClient = createWalletClient({
  chain: sepolia,
  transport: custom(window.ethereum!),
});

const mySepolia = {
  ...sepoliaFhe,
  relayerUrl: "https://your-app.com/api/relayer/11155111",
} as const satisfies FheChain;

const config = createConfig({
  chains: [mySepolia],
  publicClient,
  walletClient,
  relayers: {
    [mySepolia.id]: web(),
  },
});

const sdk = new ZamaSDK(config);
```

--------------------------------

### Clone FHEVM Foundry Template

Source: https://docs.zama.org/protocol/solidity-guides/getting-started/setup-1.md

Clone the official FHEVM Foundry template repository to get a pre-configured setup for FHEVM smart contract development.

```bash
git clone https://github.com/zama-ai/fhevm-foundry-template
cd fhevm-foundry-template
```

--------------------------------

### Reset FHEVM Hardhat Project

Source: https://docs.zama.org/protocol/solidity-guides/getting-started/setup.md

Remove all example code, test files, contracts, deployment scripts, and generated artifacts/cache to start with a clean project structure.

```sh
rm -rf test/* contracts/* deploy ./fhevmTemp ./artifacts ./cache ./coverage ./types ./coverage.json ./dist
```

--------------------------------

### Configure Environment Variables for Sepolia Deployment

Source: https://docs.zama.org/protocol/solidity-guides/development-guide/foundry/deploy.md

Copy the example environment file and fill in your private key and RPC URL. Source the file to load these variables into your shell.

```bash
cp .env.example .env
```

```bash
# .env
DEPLOYER_PRIVATE_KEY=0x...
RPC_URL=https://sepolia.infura.io/v3/<key>
# ETHERSCAN_API_KEY=...   # optional, for verification
```

```bash
source .env
```

--------------------------------

### Querying Documentation with Parameters

Source: https://docs.zama.org/protocol/protocol/overview.md

Demonstrates how to perform an HTTP GET request to query the documentation dynamically. Use the `ask` parameter for your question and optionally the `goal` parameter for broader context.

```http
GET https://docs.zama.org/protocol/protocol/overview.md?ask=<question>&goal=<endgoal>
```

--------------------------------

### Configure fromIndex for useTokenPairsSlice

Source: https://docs.zama.org/protocol/sdk/api-references/react/usetokenpairsslice.md

Example of setting the `fromIndex` parameter to specify the starting point (inclusive) for fetching token pairs. Pass `undefined` to disable the query.

```typescript
useTokenPairsSlice({ fromIndex: 0n, toIndex: 10n });
```

--------------------------------

### Authorize Contracts with useGrantPermit

Source: https://docs.zama.org/protocol/sdk/api-references/react/usegrantpermit.md

Use the useGrantPermit hook to get a mutation function for authorizing contract addresses. This example shows how to trigger the permit granting process when a button is clicked.

```typescript
import { useGrantPermit } from "@zama-fhe/react-sdk";

function AllowButton({ contracts }: { contracts: `0x${string}`[] }) {
  const { mutateAsync: grantPermit, isPending } = useGrantPermit();

  const handleAllow = async () => {
    await grantPermit(contracts);
    // All subsequent decrypt operations reuse the cached permits
  };

  return (
    <button onClick={handleAllow} disabled={isPending}>
      {isPending ? "Signing..." : "Authorize contracts"}
    </button>
  );
}
```

--------------------------------

### Set Hardhat Configuration Variable INFURA_API_KEY

Source: https://docs.zama.org/protocol/solidity-guides/getting-started/setup.md

Configure the INFURA_API_KEY variable to connect to Ethereum testnets like Sepolia. Obtain your key by following the Infura + MetaMask setup guide.

```sh
npx hardhat vars set INFURA_API_KEY
```

--------------------------------

### Query Documentation with Hardhat

Source: https://docs.zama.org/protocol/solidity-guides/development-guide/hardhat/write_test.md

Demonstrates how to query documentation dynamically using an HTTP GET request with 'ask' and 'goal' query parameters. This is useful for retrieving specific information or clarification not explicitly found on a page.

```HTTP
GET https://docs.zama.org/protocol/solidity-guides/development-guide/hardhat/write_test.md?ask=<question>&goal=<endgoal>
```

--------------------------------

### Use useConfidentialBalance in a Component

Source: https://docs.zama.org/protocol/sdk/api-references/react/useconfidentialbalance.md

Fetch and display a token's confidential balance. This example shows how to use the hook with wagmi's useAccount to get the connected address. It handles loading and error states.

```typescript
import { useConfidentialBalance } from "@zama-fhe/react-sdk";
import { useAccount } from "wagmi";

function TokenBalance({ tokenAddress }: { tokenAddress: `0x${string}` }) {
  const { address } = useAccount();
  const { 
    data: balance, 
    isLoading, 
    error, 
  } = useConfidentialBalance({
    address: tokenAddress,
    account: address,
  });

  if (isLoading) return <span>Decrypting...</span>;
  if (error) return <span>Error: {error.message}</span>;
  return <span>{balance?.toString()}</span>;
}
```

--------------------------------

### Querying Documentation Dynamically

Source: https://docs.zama.org/protocol/sdk/api-references/react/useunwrap.md

Demonstrates how to query the documentation dynamically using a GET request with 'ask' and optional 'goal' query parameters.

```http
GET https://docs.zama.org/protocol/sdk/api-references/react/useunwrap.md?ask=<question>&goal=<endgoal>
```

--------------------------------

### Set up Zama SDK for Node.js with viem

Source: https://docs.zama.org/protocol/sdk/getting-started/quick-start.md

Configure the Zama SDK for a Node.js environment using viem. This example uses environment variables for private keys and RPC URLs and sets up memory storage for the SDK.

```ts
import { createConfig } from "@zama-fhe/sdk/viem";
import { ZamaSDK, memoryStorage } from "@zama-fhe/sdk";
import { node } from "@zama-fhe/sdk/node";
import { sepolia, type FheChain } from "@zama-fhe/sdk/chains";
import { createPublicClient, createWalletClient, http } from "viem";
import { privateKeyToAccount } from "viem/accounts";
import { sepolia as sepoliaViem } from "viem/chains";

const account = privateKeyToAccount(process.env.PRIVATE_KEY as `0x${string}`);
const publicClient = createPublicClient({
  chain: sepoliaViem,
  transport: http(process.env.RPC_URL),
});
const walletClient = createWalletClient({
  account,
  chain: sepoliaViem,
  transport: http(process.env.RPC_URL),
});

const mySepolia = { ...sepolia, network: process.env.RPC_URL! } as const satisfies FheChain;

const config = createConfig({
  chains: [mySepolia],
  publicClient,
  walletClient,
  storage: memoryStorage,
  relayers: {
    [mySepolia.id]: node({ poolSize: 4 }),
  },
});

const sdk = new ZamaSDK(config);
```

--------------------------------

### Check Started

Source: https://docs.zama.org/protocol/protocol-apps/staking.md

Checks if the rewarder has been started and is currently accepting reward claims.

```APIDOC
## Check Started

### Description
Returns `true` if the rewarder has been started and is accepting reward claims.

### Method
CALL (Solidity View Function)

### Endpoint
N/A (Direct contract interaction)

### Parameters
None

### Response
#### Success Response
- **started** (bool) - `true` if the rewarder is started, `false` otherwise.

### Response Example
```json
{
  "started": true
}
```
```

--------------------------------

### Query Documentation with Agent

Source: https://docs.zama.org/protocol/solidity-guides/smart-contract/configure.md

Perform an HTTP GET request to query documentation dynamically. Use the 'ask' parameter for specific questions and the optional 'goal' parameter to tailor the response.

```http
GET https://docs.zama.org/protocol/solidity-guides/smart-contract/configure.md?ask=<question>&goal=<endgoal>
```

--------------------------------

### Check if Rewarder Started

Source: https://docs.zama.org/protocol/protocol-apps/staking.md

Returns true if the rewarder has been started and is actively accepting reward claims.

```solidity
bool started = operatorRewarder.isStarted();
```

--------------------------------

### useUnderlyingAllowance Parameters Example

Source: https://docs.zama.org/protocol/sdk/api-references/react/useunderlyingallowance.md

Example demonstrating the parameters for the `useUnderlyingAllowance` hook, specifically the `address` and `owner`.

```typescript
const { data: allowance } = useUnderlyingAllowance({
  address: "0xWrapper",
  owner: "0xOwner",
});
```

--------------------------------

### Query Documentation with `ask` and `goal` Parameters

Source: https://docs.zama.org/protocol/protocol-apps/addresses/testnet/sepolia.md

Use this HTTP GET request to query the documentation dynamically. The `ask` parameter specifies your question, and the optional `goal` parameter provides context for your end objective.

```http
GET https://docs.zama.org/protocol/protocol-apps/addresses/testnet/sepolia.md?ask=<question>&goal=<endgoal>
```

--------------------------------

### useWrapperDiscovery Parameters Example

Source: https://docs.zama.org/protocol/sdk/api-references/react/usewrapperdiscovery.md

Example demonstrating the parameters for the useWrapperDiscovery hook, specifically tokenAddress and erc20Address.

```typescript
useWrapperDiscovery({
  tokenAddress: "0xConfidentialToken",
  erc20Address: "0xUSDC",
});
```

--------------------------------

### Querying Documentation with Ask Parameter

Source: https://docs.zama.org/protocol/solidity-guides/smart-contract/configure/contract_addresses.md

Demonstrates how to query documentation dynamically using the `ask` and optional `goal` query parameters in an HTTP GET request. This is useful for retrieving information not explicitly present on the page or for clarification.

```http
GET https://docs.zama.org/protocol/solidity-guides/smart-contract/configure/contract_addresses.md?ask=<question>&goal=<endgoal>
```

--------------------------------

### Querying Documentation with GET Request

Source: https://docs.zama.org/protocol/sdk/api-references/sdk/genericsigner.md

To get additional information not directly on the page, perform an HTTP GET request to the current page URL with the `ask` query parameter for your question and an optional `goal` parameter for the broader objective.

```http
GET https://docs.zama.org/protocol/sdk/api-references/sdk/genericsigner.md?ask=<question>&goal=<endgoal>
```

--------------------------------

### Query Documentation with Ask and Goal Parameters

Source: https://docs.zama.org/protocol/examples/auctions

Use this GET request to query the documentation dynamically. Include your specific question in the 'ask' parameter and an optional broader goal in the 'goal' parameter.

```http
GET https://docs.zama.org/protocol/examples/auctions.md?ask=<question>&goal=<endgoal>
```

--------------------------------

### React (wagmi) SDK: After v3.x

Source: https://docs.zama.org/protocol/sdk/migration/migrate-v2-to-v3.md

Example of setting up the ZamaProvider with wagmi adapter in version 3.x. Configuration is simplified using `createConfig` and TanStack Query is integrated.

```tsx
import { ZamaProvider } from "@zama-fhe/react-sdk";
import { createConfig as createZamaConfig } from "@zama-fhe/react-sdk/wagmi";
import { indexedDBStorage } from "@zama-fhe/sdk";
import { sepolia as fheSepolia, type FheChain } from "@zama-fhe/sdk/chains";
import { web } from "@zama-fhe/sdk/web";
import { QueryClient, QueryClientProvider } from "@tanstack/react-query";

const queryClient = new QueryClient();

const mySepolia = {
  ...fheSepolia,
  relayerUrl: "/api/relayer",
  network: SEPOLIA_RPC_URL,
} as const satisfies FheChain;

const zamaConfig = createZamaConfig({
  chains: [mySepolia],
  wagmiConfig,
  relayers: { [mySepolia.id]: web() },
  storage: indexedDBStorage,
  // permitStorage defaults to `storage`; pass it only to split the backing store.
  onEvent: handleEvent,
});

<WagmiProvider config={wagmiConfig}>
  <QueryClientProvider client={queryClient}>
    <ZamaProvider config={zamaConfig}>{children}</ZamaProvider>
  </QueryClientProvider>
</WagmiProvider>;

```

--------------------------------

### Node.js Configuration

Source: https://docs.zama.org/protocol/sdk/guides/configuration.md

Set up the Zama SDK for Node.js environments. This example uses viem for client configuration and specifies a network URL for the chain.

```ts
import { createConfig } from "@zama-fhe/sdk/viem";
import { ZamaSDK, memoryStorage } from "@zama-fhe/sdk";
import { node } from "@zama-fhe/sdk/node";
import { sepolia, type FheChain } from "@zama-fhe/sdk/chains";

const mySepolia = {
  ...sepolia,
  network: "https://sepolia.infura.io/v3/YOUR_KEY",
} as const satisfies FheChain;

const config = createConfig({
  chains: [mySepolia],
  publicClient,
  walletClient,
  storage: memoryStorage,
  relayers: {
    [mySepolia.id]: node({ poolSize: 4 }),
  },
});

const sdk = new ZamaSDK(config);
```

--------------------------------

### Instantiate ViemSigner with WalletClient and Ethereum Provider (Constructor Detail)

Source: https://docs.zama.org/protocol/sdk/api-references/sdk/viemsigner.md

Demonstrates the constructor for ViemSigner, explicitly showing the inclusion of the raw EIP-1193 provider for wallet event subscriptions.

```typescript
const signer = new ViemSigner({
  walletClient,
  ethereum: window.ethereum,
});
```

--------------------------------

### Example: Building Handles List for Signature Verification

Source: https://docs.zama.org/protocol/solidity-guides/smart-contract/functions.md

Illustrates how to use `FHE.toBytes32` to convert encrypted values into `bytes32` handles, which are then collected into an array for use with functions like `checkSignatures`.

```solidity
bytes32[] memory handles = new bytes32[](2);
handles[0] = FHE.toBytes32(encryptedFoo);
handles[1] = FHE.toBytes32(encryptedBar);
```

--------------------------------

### React (wagmi) SDK: Before v2.x

Source: https://docs.zama.org/protocol/sdk/migration/migrate-v2-to-v3.md

Example of setting up the ZamaProvider with wagmi adapter in version 2.x. It shows manual configuration of the relayer and storage.

```tsx
import { ZamaProvider, RelayerWeb, indexedDBStorage, IndexedDBStorage } from "@zama-fhe/react-sdk";
import { WagmiSigner } from "@zama-fhe/react-sdk/wagmi";
import { SepoliaConfig } from "@zama-fhe/sdk";

const signer = new WagmiSigner({ config: wagmiConfig });
const sessionDBStorage = new IndexedDBStorage("SessionStore");

const relayer = useMemo(
  () =>
    new RelayerWeb({
      getChainId: () => signer.getChainId(),
      transports: {
        [SepoliaConfig.chainId]: {
          ...SepoliaConfig,
          relayerUrl: `${window.location.origin}/api/relayer`,
          network: SEPOLIA_RPC_URL,
        },
      },
    }),
  [],
);

<WagmiProvider config={wagmiConfig}>
  <ZamaProvider
    relayer={relayer}
    signer={signer}
    storage={indexedDBStorage}
    sessionStorage={sessionDBStorage}
    onEvent={handleEvent}
  >
    {children}
  </ZamaProvider>
</WagmiProvider>;

```

--------------------------------

### Install Dependencies with Soldeer

Source: https://docs.zama.org/protocol/solidity-guides/getting-started/setup-1.md

Use Soldeer to install project dependencies, including forge-fhevm, encrypted-types, and OpenZeppelin contracts, into the `dependencies/` directory.

```bash
forge soldeer install
```

--------------------------------

### Set up FHEVM Test Contract

Source: https://docs.zama.org/protocol/solidity-guides/development-guide/foundry/write_test.md

Inherit from FhevmTest and call super.setUp() to deploy FHEVM host contracts. Ensure the contract under test has a Zama config.

```solidity
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.27;

import {FhevmTest} from "forge-fhevm/FhevmTest.sol";
import {FHE} from "@fhevm/solidity/lib/FHE.sol";
import "encrypted-types/EncryptedTypes.sol";

contract MyTest is FhevmTest {
    MyContract myContract;

    function setUp() public override {
        super.setUp(); // deploy FHEVM host contracts
        myContract = new MyContract();
    }
}
```

--------------------------------

### Query Documentation with GitBook Agent

Source: https://docs.zama.org/protocol/examples/openzeppelin-confidential-contracts/erc7984/swaperc7984toerc20.md

Use this HTTP GET request to query the documentation dynamically. Include an 'ask' parameter for your specific question and an optional 'goal' parameter for broader context. The response will provide a direct answer and relevant excerpts.

```http
GET https://docs.zama.org/protocol/examples/openzeppelin-confidential-contracts/erc7984/swaperc7984toerc20.md?ask=<question>&goal=<endgoal>
```

--------------------------------

### Install Zama Skills for Other Agents

Source: https://docs.zama.org/protocol/sdk/getting-started/build-with-an-llm.md

Install the Zama skills for other skill-aware agents using npx. You can use the --list flag to choose specific skills.

```bash
npx skills add zama-ai/skills
```

--------------------------------

### Initialize ViemSigner with WalletClient and Ethereum Provider

Source: https://docs.zama.org/protocol/sdk/api-references/sdk/viemsigner.md

Instantiate ViemSigner with a viem WalletClient and an EIP-1193 provider. This setup allows the signer to emit wallet lifecycle events.

```typescript
import { createWalletClient, custom } from "viem";
import { sepolia } from "viem/chains";
import { ViemSigner } from "@zama-fhe/sdk/viem";

const walletClient = createWalletClient({
  chain: sepolia,
  transport: custom(window.ethereum!),
});

const signer = new ViemSigner({ walletClient, ethereum: window.ethereum });
```

--------------------------------

### Query Documentation API

Source: https://docs.zama.org/protocol/sdk/api-references/react/usefinalizeunwrap.md

Demonstrates how to query the documentation dynamically using an HTTP GET request with 'ask' and optional 'goal' query parameters.

```http
GET https://docs.zama.org/protocol/sdk/api-references/react/usefinalizeunwrap.md?ask=<question>&goal=<endgoal>
```

--------------------------------

### Get All Confidential (Token, Wrapper) Pairs

Source: https://docs.zama.org/protocol/protocol-apps/confidential-tokens/wrapper-registry.md

Retrieves all registered confidential token and wrapper pairs, including those that have been revoked. Use this to get a comprehensive list of all pairs.

```Solidity
TokenWrapperPair[] memory tokenConfidentialTokenPairs = registry.getTokenConfidentialTokenPairs();
```
Tokens:
Raw