GenericStorage

Interface for async key-value storage used to persist transport key pairs and signed permits.

Interface for async key-value storage used to persist transport key pairs and signed permits. The SDK ships with four built-in implementations -- you only need this interface if building a custom backend.

Import

import type { GenericStorage } from "@zama-fhe/sdk";

Definition

interface GenericStorage {
  get<T = unknown>(key: string): Promise<T | null>;
  set<T = unknown>(key: string, value: T): Promise<void>;
  delete(key: string): Promise<void>;
}

Usage

import { ZamaSDK } from "@zama-fhe/sdk";
import type { GenericStorage } from "@zama-fhe/sdk";

const redisStorage: GenericStorage = {
  async get(key) {
    return redis.get(key);
  },
  async set(key, value) {
    await redis.set(key, value);
  },
  async delete(key) {
    await redis.del(key);
  },
};

const config = createConfig({
  chains: [sepolia],
  signer: mySigner,
  provider: myProvider,
  storage: redisStorage,
  relayers: { [sepolia.id]: node() },
});
const sdk = new ZamaSDK(config);

Methods

get

get<T = unknown>(key: string): Promise<T | null>

Retrieve a value by key. Return null if the key does not exist. The generic T allows typed reads.

set

set<T = unknown>(key: string, value: T): Promise<void>

Store a value under the given key. Overwrites any existing value. Accepts any serializable type.

delete

delete(key: string): Promise<void>

Remove a key and its value. No-op if the key does not exist.

Built-in implementations

indexedDBStorage

import { indexedDBStorage } from "@zama-fhe/sdk";

Browser-based persistent storage backed by IndexedDB. Survives page reloads and browser restarts. Use this as the primary storage in browser apps.

const sdk = new ZamaSDK(config); // config from createConfig()

memoryStorage

import { memoryStorage } from "@zama-fhe/sdk";

In-memory storage cleared when the process exits. Suitable for tests and throwaway scripts.

const sdk = new ZamaSDK(config); // config from createConfig()

asyncLocalStorage

import { asyncLocalStorage } from "@zama-fhe/sdk/node";

Node.js per-request storage using AsyncLocalStorage. Isolates transport key pairs across concurrent requests on a server.

import { asyncLocalStorage } from "@zama-fhe/sdk/node";

app.post("/api/transfer", (req, res) => {
  asyncLocalStorage.run(async () => {
    const config = createConfig({
      chains: [mySepolia],
      signer: wallet,
      storage: asyncLocalStorage,
      relayers: { [mySepolia.id]: node() },
    });
    const sdk = new ZamaSDK(config);
    await sdk.createToken("0x...").confidentialTransfer("0x...", 100n);
  });
});

chromeSessionStorage

import { chromeSessionStorage } from "@zama-fhe/sdk";

MV3 web extension storage backed by chrome.storage.session. Survives service worker restarts and is shared across popup, background, and content script contexts. Cleared when the browser closes.

Pass as permitStorage (not storage) to persist signed permits across service worker restarts:

const config = createConfig({
  chains: [mySepolia],
  publicClient,
  walletClient,
  storage: indexedDBStorage,
  permitStorage: chromeSessionStorage,
  relayers: { [mySepolia.id]: web() },
});
const sdk = new ZamaSDK(config);

Related

• ZamaSDK -- accepts storage and permitStorage parameters

• Configuration guide -- storage selection guidance