FHEVM

https://github.com/zama-ai/fhevm
Admin
FHEVM, a full-stack framework for integrating Fully Homomorphic Encryption (FHE) with blockchain...
Tokens:318,567
Snippets:1,772
Trust Score:9.8
License:BSD-3-Clause
Update:9 months ago
Show doc for...
Tokens:
Raw
### TypeScript Test Setup for Vesting Wallet

Source: https://github.com/zama-ai/fhevm/blob/main/docs/examples/openzeppelin/vesting-wallet.md

Provides the initial setup for testing the VestingWalletExample smart contract using TypeScript and Chai. This snippet imports the 'expect' assertion library from Chai.

```typescript
import { expect } from 'chai';

```

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

### Hardhat Configuration for OFTAdapter

Source: https://github.com/zama-ai/fhevm/blob/main/protocol-contracts/token/README.md

Illustrates how to update the hardhat.config.ts file to specify the token address for the ZamaOFTAdapter contract.

```typescript
oftAdapter: {
    tokenAddress: '0x0' // Replace `0x0` with the address of the ERC20 token you want to adapt to the OFT functionality.
}
```

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

### Verify Contracts on Etherscan

Source: https://github.com/zama-ai/fhevm/blob/main/protocol-contracts/token/README.md

Commands to verify ZamaERC20 and ZamaOFTAdapter contracts on Ethereum Sepolia, and ZamaOFT on Gateway Testnet using pnpm.

```bash
pnpm verify:etherscan:ethereum:sepolia
pnpm verify:etherscan:gateway:testnet
```

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

### FHEVM Test Setup and Utilities (TypeScript)

Source: https://github.com/zama-ai/fhevm/blob/main/docs/examples/sealed-bid-auction.md

Sets up the testing environment for the Blind Auction contract using FHEVM. It includes fixtures for deploying contracts, signer configurations, and utility functions for encrypting bids, getting balances, and performing minting operations. This setup ensures that all interactions with the Blind Auction and USDC contracts are performed within the FHE environment.

```typescript
import { HardhatEthersSigner } from "@nomicfoundation/hardhat-ethers/signers";

describe("BlindAuction", function () {
  before(async function () {
    if (!hre.fhevm.isMock) {
      throw new Error(`This hardhat test suite cannot run on Sepolia Testnet`);
    }
    this.signers = {} as Signers;

    const signers = await ethers.getSigners();
    this.signers.owner = signers[0];
    this.signers.alice = signers[1];
    this.signers.bob = signers[2];
  });

  beforeEach(async function () {
    const deployment = await deployBlindAuctionFixture(this.signers.owner);

    this.USDCc = deployment.USDCc;
    this.prizeItem = deployment.prizeItem;
    this.blindAuction = deployment.blindAuction;

    this.USDCcAddress = deployment.USDCc_address;
    this.prizeItemAddress = deployment.prizeItem_address;
    this.blindAuctionAddress = deployment.blindAuction_address;

    this.getUSDCcBalance = async (signer: HardhatEthersSigner) => {
      const encryptedBalance = await this.USDCc.confidentialBalanceOf(signer.address);
      return await hre.fhevm.userDecryptEuint(FhevmType.euint64, encryptedBalance, this.USDCcAddress, signer);
    };

    this.encryptBid = async (targetContract: string, userAddress: string, amount: number) => {
      const bidInput = hre.fhevm.createEncryptedInput(targetContract, userAddress);
      bidInput.add64(amount);
      return await bidInput.encrypt();
    };

    this.approve = async (signer: HardhatEthersSigner) => {
      // Approve to send the fund
      const approveTx = await this.USDCc.connect(signer)("setOperator(address, uint48)")( 
        this.blindAuctionAddress,
        Math.floor(Date.now() / 1000) + 60 * 60,
      );
      await approveTx.wait();
    };

    this.bid = async (signer: HardhatEthersSigner, amount: number) => {
      const encryptedBid = await this.encryptBid(this.blindAuctionAddress, signer.address, amount);
      const bidTx = await this.blindAuction.connect(signer).bid(encryptedBid.handles[0], encryptedBid.inputProof);
      await bidTx.wait();
    };

    this.mintUSDc = async (signer: HardhatEthersSigner, amount: number) => {
      // Use the simpler mint function that doesn't require FHE encryption
      const mintTx = await this.USDCc.mint(signer.address, amount);
      await mintTx.wait();
    };
  });

  // ... test cases follow ...
});
```

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

### Install Dependencies and Deploy Local Hardhat Chain

Source: https://github.com/zama-ai/fhevm/blob/main/docs/examples/wallet-guide.md

This snippet outlines the commands to install project dependencies, deploy a local Hardhat development chain, and deploy contracts to it. It's a prerequisite for running the ERC-7984 demo application locally.

```bash
pnpm install
pnpm chain
pnpm deploy:localhost
```

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

### Manual Deployment of Zama Contracts

Source: https://github.com/zama-ai/fhevm/blob/main/protocol-contracts/token/README.md

Manually deploys the ZamaERC20, ZamaOFTAdapter, and ZamaOFT contracts using Hardhat tasks. This involves multiple steps for each contract and network configuration.

```bash
pnpm i
npx hardhat lz:deploy
```

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

### FHEVM Plugin Import and Setup in TypeScript

Source: https://github.com/zama-ai/fhevm/blob/main/docs/examples/sealed-bid-auction.md

Imports necessary modules from the FHEVM library and Hardhat for setting up tests. It defines type aliases for signers and imports fixture functions for deploying the Blind Auction contract. This snippet demonstrates the foundational setup for testing FHE-enabled smart contracts.

```TypeScript
import { FhevmType } from "@fhevm/hardhat-plugin";
import { expect } from "chai";
import { ethers } from "ethers";
import { time } from "@nomicfoundation/hardhat-network-helpers";
import * as hre from "hardhat";

type Signers = {
  owner: HardhatEthersSigner;
  alice: HardhatEthersSigner;
  bob: HardhatEthersSigner;
};

import { deployBlindAuctionFixture } from "./BlindAuction.fixture";

```

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

### Deploy FHEVM e2e Setup

Source: https://github.com/zama-ai/fhevm/blob/main/test-suite/gateway-stress/README.md

Command to deploy the end-to-end setup for the FHEVM tool from the root of the fhevm repository. This is a prerequisite for further local testing.

```bash
cd test-suite/fhevm
./fhevm-cli deploy
```

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

### Automated Token Deployment (Testnet)

Source: https://github.com/zama-ai/fhevm/blob/main/protocol-contracts/token/README.md

Executes a Hardhat task to automatically deploy the ZamaERC20, ZamaOFTAdapter, and ZamaOFT contracts on the testnet. It includes optional Etherscan verification.

```bash
npx hardhat deploy:token --preset testnet
```

```bash
npx hardhat deploy:token --preset testnet --verify true
```

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

### Start Docker Compose for Database

Source: https://github.com/zama-ai/fhevm/blob/main/coprocessor/fhevm-engine/tfhe-worker/README.md

Starts the database services defined in the docker-compose.yml file in detached mode. This is a prerequisite for development and requires Docker to be installed and running.

```bash
docker compose up -d
```

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

### Transfer Ownership of ZamaOFT

Source: https://github.com/zama-ai/fhevm/blob/main/protocol-contracts/token/README.md

Transfers the ownership of the ZamaOFT contract to a new address. The contract address can be loaded from environment variables or specified directly.

```bash
npx hardhat zama:oft:transferOwnership --address <new_owner> --network <your_network>
```

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

### Navigate to ERC-7984 Demo Folder

Source: https://github.com/zama-ai/fhevm/blob/main/docs/examples/wallet-guide.md

This command navigates the user into the specific directory for the ERC-7984 example application within the cloned repository. This is a necessary step before running the demo.

```bash
cd packages/erc7984example
```

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

### Set Delegate on ZamaOFT

Source: https://github.com/zama-ai/fhevm/blob/main/protocol-contracts/token/README.md

Sets a new delegate address for the ZamaOFT contract. The contract address can be loaded from environment variables or specified directly.

```bash
npx hardhat zama:oft:setDelegate --address <new_delegate> --network <your_network>
```

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

### Install bun for FHEVM CLI

Source: https://github.com/zama-ai/fhevm/blob/main/protocol-contracts/deployment-cli/README.md

Installs the bun JavaScript runtime, which is recommended for running the FHEVM deployment CLI. This command fetches the installation script and executes it.

```bash
curl -fsSL https://bun.sh/install | bash
```

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

### Install Dependencies via npm

Source: https://github.com/zama-ai/fhevm/blob/main/protocol-contracts/fhevm-cli/README.md

Installs project dependencies using npm. Ensure you have Node.js and npm installed. This is a prerequisite for running other CLI commands.

```bash
npm i
```

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

### Install KMS Connector Helm Chart from hub.zama.ai

Source: https://github.com/zama-ai/fhevm/blob/main/charts/kms-connector/README.md

Installs the KMS Connector Helm chart from the hub.zama.ai registry. This requires logging into the hub.zama.ai registry before executing the Helm installation command.

```bash
helm registry login hub.zama.ai
helm install kms oci://hub.zama.ai/zama-protocol/zama-ai/fhevm/charts/kms-connector
```

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

### Inherit ZamaEthereumConfig for Automatic FHEVM Setup

Source: https://github.com/zama-ai/fhevm/blob/main/docs/solidity-guides/configure.md

This example demonstrates how to inherit from ZamaEthereumConfig to automatically set up the FHEVM coprocessor in your smart contract. The constructor of ZamaEthereumConfig handles wiring the contract to the correct FHEVM contracts for the target network, abstracting manual address management.

```solidity
// SPDX-License-Identifier: BSD-3-Clause-Clear
pragma solidity ^0.8.24;

import { ZamaEthereumConfig } from "@fhevm/solidity/config/ZamaConfig.sol";

contract MyERC20 is ZamaEthereumConfig {
  constructor() {
    // Additional initialization logic if needed
  }
}
```

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

### Install KMS Connector Helm Chart from ghcr.io

Source: https://github.com/zama-ai/fhevm/blob/main/charts/kms-connector/README.md

Installs the KMS Connector Helm chart from the ghcr.io registry. This involves logging into the registry and then performing the installation using the 'helm install' command.

```bash
helm registry login ghcr.io/zama-ai/fhevm/charts
helm install kms-connector oci://ghcr.io/zama-ai/fhevm/charts/kms-connector
```

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

### Install Dependencies for FHEVM CLI

Source: https://github.com/zama-ai/fhevm/blob/main/protocol-contracts/deployment-cli/README.md

Installs the necessary project dependencies using bun. This command should be run after cloning the repository and ensures all required packages are available for the CLI.

```bash
bun i
```

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

### Revoke Role on ZamaERC20

Source: https://github.com/zama-ai/fhevm/blob/main/protocol-contracts/token/README.md

Revokes a specific role from an address on the ZamaERC20 contract. Examples include revoking minter or pauser roles. The contract address can be loaded from environment variables or specified directly.

```bash
npx hardhat zama:erc20:revoke:<role_name> --address <ADDRESS_TO_REVOKE_FROM> --network <your_network>
```

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

### Local Test Database Setup (PostgreSQL)

Source: https://github.com/zama-ai/fhevm/blob/main/coprocessor/fhevm-engine/host-listener/README.md

Inserts a new tenant record into the PostgreSQL database for local testing purposes. This command is used when a coprocessor API key is not readily available and a database needs to be initialized for local development.

```sql
psql
postgres=# insert into tenants values (13, '00000000000000000000000000000000', 0, 'contract verify', 'contract acl', '0'::bytea, '0'::bytea, '0'::bytea);

```

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

### Copy Environment File

Source: https://github.com/zama-ai/fhevm/blob/main/protocol-contracts/pauserSetWrapper/README.md

This command copies the example environment file to a new file named `.env`. This is a prerequisite for configuring the project with specific network details and private keys.

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

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

### Create Relayer SDK Instance

Source: https://github.com/zama-ai/fhevm/blob/main/docs/sdk-guides/webapp.md

This JavaScript code demonstrates the complete process of initializing the Relayer SDK and then creating an instance. It first awaits the loading of WASM components using `initSDK`, then configures the instance with network settings (like SepoliaConfig and `window.ethereum`), and finally calls `createInstance`.

```javascript
import { initSDK, createInstance, SepoliaConfig } from "@zama-fhe/relayer-sdk/bundle";

const init = async () => {
  await initSDK(); // Load FHE
  const config = { ...SepoliaConfig, network: window.ethereum };
  return createInstance(config);
};

init().then((instance) => {
  console.log(instance);
});
```

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

### Get Slice of Token-Confidential Wrapper Pairs (Solidity)

Source: https://github.com/zama-ai/fhevm/blob/main/protocol-contracts/confidential-token-wrappers-registry/docs/README.md

Retrieves a subset (slice) of TokenWrapperPair structs from the registry, specified by a starting and ending index. The range is inclusive of the start index and exclusive of the end index. Revoked wrappers may be included in the slice.

```solidity
TokenWrapperPair[] memory tokenConfidentialTokenPairsSlice = registry.getTokenConfidentialTokenPairsSlice(fromIndex, toIndex);
```

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

### Instantiate FHEVM Instance with Manual Configuration (TypeScript)

Source: https://github.com/zama-ai/fhevm/blob/main/docs/sdk-guides/initialization.md

This snippet demonstrates how to create an FhevmInstance by manually providing all necessary configuration parameters, including contract addresses for ACL, KMS, input verifier, and verifying contracts, along with FHEVM and gateway chain IDs. It also shows how to specify the network RPC provider and relayer URL. Dependencies include the '@zama-fhe/relayer-sdk'.

```typescript
import { createInstance } from "@zama-fhe/relayer-sdk";

const instance = await createInstance({
  // ACL_CONTRACT_ADDRESS (FHEVM Host chain)
  aclContractAddress: "0x687820221192C5B662b25367F70076A37bc79b6c",
  // KMS_VERIFIER_CONTRACT_ADDRESS (FHEVM Host chain)
  kmsContractAddress: "0x1364cBBf2cDF5032C47d8226a6f6FBD2AFCDacAC",
  // INPUT_VERIFIER_CONTRACT_ADDRESS (FHEVM Host chain)
  inputVerifierContractAddress: "0xbc91f3daD1A5F19F8390c400196e58073B6a0BC4",
  // DECRYPTION_ADDRESS (Gateway chain)
  verifyingContractAddressDecryption: "0xb6E160B1ff80D67Bfe90A85eE06Ce0A2613607D1",
  // INPUT_VERIFICATION_ADDRESS (Gateway chain)
  verifyingContractAddressInputVerification: "0x7048C39f048125eDa9d678AEbaDfB22F7900a29F",
  // FHEVM Host chain id
  chainId: 11155111,
  // Gateway chain id
  gatewayChainId: 55815,
  // Optional RPC provider to host chain
  network: "https://eth-sepolia.public.blastapi.io",
  // Relayer URL
  relayerUrl: "https://relayer.testnet.zama.cloud",
});
```

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

### cli Command-Line Help

Source: https://github.com/zama-ai/fhevm/blob/main/coprocessor/README.md

Displays help information for the cli tool, which provides commands for interacting with the coprocessor. Key commands include 'insert-tenant' for database operations and 'smoke-test' for coprocessor verification. It also supports standard help and version flags.

```bash
$ cli --help
Usage: cli <COMMAND>

Commands:
  insert-tenant  Inserts tenant into specified database
  smoke-test     Coprocessor smoke test
  help           Print this message or the help of the given subcommand(s)

Options:
  -h, --help     Print help
  -V, --version  Print version
```

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

### KMSGenerationV2 Example Functions

Source: https://github.com/zama-ai/fhevm/blob/main/gateway-contracts/selectors.txt

This section outlines the available functions for KMS generation in version 2, including their signatures and selectors.

```APIDOC
## KMSGenerationV2 Functions

### Description
This section details the functions available for KMS generation in version 2, including their types, signatures, and selectors.

### Functions

| Type     | Signature                                              | Selector |
|----------+--------------------------------------------------------+--------------------------------------------------------------------|
| Function | UPGRADE_INTERFACE_VERSION()                            | 0xad3cb1cc |
| Function | crsgenRequest(uint256,uint8)                           | 0x3c02f834 |
| Function | crsgenResponse(uint256,bytes,bytes)                    | 0x62978787 |
| Function | eip712Domain()                                         | 0x84b0196e |
| Function | getActiveCrsId()                                       | 0xbaff211e |
| Function | getActiveKeyId()                                       | 0xd52f10eb |
| Function | getConsensusTxSenders(uint256)                         | 0x16c713d9 |
| Function | getCrsMaterials(uint256)                               | 0xc55b8724 |
| Function | getCrsParamsType(uint256)                              | 0x45af261b |
| Function | getKeyMaterials(uint256)                               | 0x936608ae |
```

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

### Transfer Ownership of ZamaOFTAdapter

Source: https://github.com/zama-ai/fhevm/blob/main/protocol-contracts/token/README.md

Transfers the ownership of the ZamaOFTAdapter contract to a new address. The contract address can be loaded from environment variables or specified directly.

```bash
npx hardhat zama:oftadapter:transferOwnership --address <new_owner> --network <your_network>
```

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

### Set Delegate on ZamaOFTAdapter

Source: https://github.com/zama-ai/fhevm/blob/main/protocol-contracts/token/README.md

Sets a new delegate address for the ZamaOFTAdapter contract. The contract address can be loaded from environment variables or specified directly.

```bash
npx hardhat zama:oftadapter:setDelegate --address <new_delegate> --network <your_network>
```

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

### Event: InitializeGatewayConfig

Source: https://github.com/zama-ai/fhevm/blob/main/gateway-contracts/selectors.txt

Emitted when the gateway configuration is initialized. This event logs the initial setup parameters for the gateway.

```APIDOC
## Event: InitializeGatewayConfig

### Description
Emitted when the gateway configuration is initialized. This event logs the initial setup parameters for the gateway.

### Parameters
- **gatewayName** (string) - The name of the gateway.
- **gatewayVersion** (string) - The version of the gateway.
- **thresholds** (object) - An object containing various threshold values (minNodes, maxNodes, threshold, timeout, reconnectionTime).
- **nodeAddresses** (array) - An array of node addresses involved in the gateway.
- **custodianAddresses** (array) - An array of custodian addresses.
- **initialKmsNodes** (array) - An array of initial KMS node configurations.

### Event Example
```json
{
  "gatewayName": "FHEVM Gateway",
  "gatewayVersion": "1.0.0",
  "thresholds": {
    "minNodes": 3,
    "maxNodes": 10,
    "threshold": 5,
    "timeout": 60,
    "reconnectionTime": 300
  },
  "nodeAddresses": ["0xnode1...", "0xnode2..."],
  "custodianAddresses": ["0xcustodian1...", "0xcustodian2..."],
  "initialKmsNodes": [
    ["0xkmsNodeAddress1", "kmsNodeId1", "endpoint1"]
  ]
}
```
```

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

### Grant Minter Role on ZamaERC20 via Contract Address

Source: https://github.com/zama-ai/fhevm/blob/main/protocol-contracts/token/README.md

Grants the MINTER_ROLE to a specified address on the ZamaERC20 contract. This task uses a directly provided contract address.

```bash
npx hardhat zama:erc20:grant:minter_role --address <NEW_MINTER_ADDRESS> --contract-address <ZAMAERC20_CONTRACT_ADDRESS>  --network ethereum-testnet
```

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

### Create Database using sqlx-cli

Source: https://github.com/zama-ai/fhevm/blob/main/coprocessor/fhevm-engine/tfhe-worker/README.md

Creates the database specified in the DATABASE_URL environment variable using the sqlx-cli tool. This command should be run after setting the DATABASE_URL.

```bash
sqlx db create
```

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

### Managing Keys with fhevm SDK Builder

Source: https://github.com/zama-ai/fhevm/blob/main/sdk/rust-sdk/README.md

This snippet illustrates key management within the fhevm SDK context. It shows how to initialize the SDK builder to use an existing keys directory or automatically generate new keys if the directory does not exist. It also includes an example of manual key generation.

```rust
let sdk = FhevmSdkBuilder::new()
    .with_keys_directory_or_generate(PathBuf::from("./keys"))?
    .build()?;

use gateway_sdk::utils::generate_fhe_keyset;
generate_fhe_keyset(Path::new("./keys"))?;
```

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

### Renounce Role on ZamaERC20

Source: https://github.com/zama-ai/fhevm/blob/main/protocol-contracts/token/README.md

Allows the currently connected signer to drop a specific role they hold on the ZamaERC20 contract. The contract address can be loaded from environment variables or specified directly.

```bash
npx hardhat zama:erc20:renounce:<role_name> --network <your_network>
```

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

### Run Hardhat Tasks (Shell)

Source: https://github.com/zama-ai/fhevm/blob/main/test-suite/e2e/README.md

This snippet shows common command-line tasks for interacting with a Hardhat project. These commands facilitate project help, running tests, reporting gas usage, starting a local development node, and deploying contracts using Hardhat Ignition.

```shell
npx hardhat help
npx hardhat test
REPORT_GAS=true npx hardhat test
npx hardhat node
npx hardhat ignition deploy ./ignition/modules/Lock.ts
```

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

### Grant Minter Role on ZamaERC20 via Deployment

Source: https://github.com/zama-ai/fhevm/blob/main/protocol-contracts/token/README.md

Grants the MINTER_ROLE to a specified address on the ZamaERC20 contract. This task fetches the contract address from deployment information for the target network.

```bash
npx hardhat zama:erc20:grant:minter_role --address <NEW_MINTER_ADDRESS> --from-deployment true --network ethereum-testnet
```

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

### TypeScript: Deploy HighestDieRoll Contract

Source: https://github.com/zama-ai/fhevm/blob/main/docs/examples/highest-die-roll.md

Deploys the HighestDieRoll contract using Hardhat and ethers. It includes setup for the FHEVM mock environment and retrieves contract details. This snippet is part of a test suite.

```typescript
import { HardhatEthersSigner } from "@nomicfoundation/hardhat-ethers/signers";
import type { ClearValueType } from "@zama-fhe/relayer-sdk/node";
import { expect } from "chai";
import { ethers as EthersT } from "ethers";
import { ethers, fhevm } from "hardhat";
import * as hre from "hardhat";

import { HighestDieRoll, HighestDieRoll__factory } from "../../../typechain-types";
import { Signers } from "../signers";

async function deployFixture() {
  // Contracts are deployed using the first signer/account by default
  const factory = (await ethers.getContractFactory("HighestDieRoll")) as HighestDieRoll__factory;
  const highestDiceRoll = (await factory.deploy()) as HighestDieRoll;
  const highestDiceRoll_address = await highestDiceRoll.getAddress();

  return { highestDiceRoll, highestDiceRoll_address };
}

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();

```

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

### Solidity: Get Game Winner

Source: https://github.com/zama-ai/fhevm/blob/main/docs/examples/highest-die-roll.md

Returns the address of the game winner. If the game is finalized, it returns the winner's address or `address(0)` if the game is a draw or not yet revealed. Requires the game to be revealed.

```solidity
/**
     * @notice Returns the address of the game winner. If the game is finalized, the function returns `address(0)`
     *         if the game is a draw.
     * @param gameId The ID of the game.
     * @return The winner's address (address(0) if not yet revealed or draw).
     */
    function getWinner(uint256 gameId) public view returns (address) {
        require(games[gameId].revealed, "Game winner not yet revealed");
        return games[gameId].winner;
    }
```

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

### Instantiate FHEVM Instance with SepoliaConfig (TypeScript)

Source: https://github.com/zama-ai/fhevm/blob/main/docs/sdk-guides/initialization.md

This snippet shows a simplified way to create an FhevmInstance using the pre-defined 'SepoliaConfig' object from the '@zama-fhe/relayer-sdk'. This configuration automatically sets up the instance with the correct parameters for the Sepolia testnet. Dependencies include the '@zama-fhe/relayer-sdk'.

```typescript
import { createInstance, SepoliaConfig } from "@zama-fhe/relayer-sdk";

const instance = await createInstance(SepoliaConfig);
```

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

### Send ZAMA Tokens: Gateway Testnet to Ethereum Sepolia

Source: https://github.com/zama-ai/fhevm/blob/main/protocol-contracts/token/README.md

NPM script to send ZAMA tokens from Gateway Testnet to Ethereum Sepolia. Requires receiver address and amount as arguments. This complements the ethToGateway transfer script.

```bash
npm run zama:oft:send:gatewayToEth -- <address> <amount>
```

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

### GatewayConfigV2 Example Function Signatures

Source: https://github.com/zama-ai/fhevm/blob/main/gateway-contracts/selectors.txt

This snippet displays function signatures from the GatewayConfigV2 example within the FHEVM project, along with their selectors. It includes functions related to upgrade interfaces and ownership management, crucial for managing contract upgrades and access control in decentralized applications.

```solidity
function UPGRADE_INTERFACE_VERSION() external pure returns (string memory);
// 0xad3cb1cc

function acceptOwnership() external;
// 0x79ba5097
```

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

### Send ZAMA Tokens: Ethereum Sepolia to Gateway Testnet

Source: https://github.com/zama-ai/fhevm/blob/main/protocol-contracts/token/README.md

NPM script to send ZAMA tokens from Ethereum Sepolia to Gateway Testnet. Requires receiver address and amount as arguments. This is a convenience script for cross-chain transfers.

```bash
npm run zama:oft:send:ethToGateway -- <address> <amount>
```

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

### On-chain Verification of Decryption Proofs (Solidity)

Source: https://github.com/zama-ai/fhevm/blob/main/docs/sdk-guides/public-decryption.md

Illustrates the on-chain verification process for decryption proofs obtained from the Relayer SDK. This involves using the `FHE.checkSignatures()` function. For a complete workflow including setup, refer to the external Solidity guide.

```solidity
// Example usage within a Solidity smart contract (conceptual)
// Assumes 'fheInstance' is an FHE contract instance and 'proof' is the cryptographic proof.
// The actual implementation details and parameters will depend on the FHE contract's interface.

// function verifyDecryption(bytes memory proof, ...) public view returns (bool) {
//   return fheInstance.checkSignatures(proof, ...);
// }
```

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

### Rust: Initialize FHEVM Gateway SDK

Source: https://github.com/zama-ai/fhevm/blob/main/sdk/rust-sdk/README.md

Initializes the FHEVM Gateway SDK with necessary configurations. This includes setting up key directories, chain IDs for gateway and host, and contract addresses for decryption and input verification. The SDK is built using a fluent builder pattern.

```rust
use gateway_sdk::{FhevmSdkBuilder, Result};
use alloy::primitives::address;
use std::path::PathBuf;

fn main() -> Result<()> {
    // Initialize SDK
    let sdk = FhevmSdkBuilder::new()
        .with_keys_directory(PathBuf::from("./keys"))
        .with_gateway_chain_id(43113)
        .with_host_chain_id(11155111)
        .with_decryption_contract("0x1234567890123456789012345678901234567bbb")
        .with_input_verification_contract("0x1234567890123456789012345678901234567aaa")
        .with_acl_contract("0x0987654321098765432109876543210987654321")
        .build()?;

    // ... rest of the code
    Ok(())
}
```

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

### Solidity: Get Player B's Die Roll

Source: https://github.com/zama-ai/fhevm/blob/main/docs/examples/highest-die-roll.md

Retrieves the encrypted die roll for Player B in a given game. This function is part of the FHEVM smart contract and returns an `euint8` handle representing the encrypted value.

```solidity
/**
     * @param gameId The ID of the game.
     * @return The encrypted result (euint8 handle).
     */
    function getPlayerBDieRoll(uint256 gameId) public view returns (euint8) {
        return games[gameId].playerBEncryptedDieRoll;
    }
```

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

### MultichainACLV2Example Functions

Source: https://github.com/zama-ai/fhevm/blob/main/gateway-contracts/selectors.txt

This section details the available functions in the MultichainACLV2Example contract, including their signatures and selectors.

```APIDOC
## MultichainACLV2Example Functions

### Description
Provides details on the functions available in the MultichainACLV2Example contract.

#### Functions

- **UPGRADE_INTERFACE_VERSION** () - 0xad3cb1cc
- **allowAccount** (bytes32, address, bytes) - 0x294a8705
- **allowPublicDecrypt** (bytes32, bytes) - 0xd90724b5
- **delegateUserDecryption** (uint256, address, address, address, uint64, uint64) - 0x4d7ab390
- **getAllowAccountConsensusTxSenders** (bytes32, address) - 0xae953186
- **getAllowPublicDecryptConsensusTxSenders** (bytes32) - 0x97c49a40
- **getDelegateUserDecryptionConsensusTxSenders** (uint256, address, address, address, uint64, uint64) - 0x29a4370d
- **getRevokeUserDecryptionDelegationConsensusTxSenders** (uint256, address, address, address, uint64, uint64) - 0x110e8755
- **getVersion** () - 0x0d8e6e2c
```

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

### Direct Cross-Chain Token Transfer with Hardhat

Source: https://github.com/zama-ai/fhevm/blob/main/protocol-contracts/token/README.md

Hardhat command for direct cross-chain token transfers using the lz:oft:send task. Allows specifying source and destination chain IDs, amount, and receiver address. This offers more granular control over transfers.

```bash
npx hardhat lz:oft:send --src-eid 40161 --dst-eid 40424 --amount 1.5 --to <RECEIVER_ADDRESS>
```
Tokens:
Raw