useEERC

The useEERC hook is the main entry point for the SDK, responsible for initializing and managing interactions with the Encrypted ERC (eERC) protocol. It connects to the eERC contract, ensuring access to core functionalities such as user registration, encrypted token management, and balance decryption.

Usage

const { publicClient } = usePublicClient();
const { walletClient } = useWalletClient();

const {
    isInitialized,
    isRegistered,
    isConverter,
    publicKey,
    auditorPublicKey,
    name,
    symbol,
    shouldGenerateDecryptionKey,
    areYouAuditor,
    hasBeenAuditor,

    // actions
    register,
    generateDecryptionKey,
    auditorDecrypt,
    isAddressRegistered,
    setContractAuditorPublicKey,
    useEncryptedBalance,
} = useEERC(
    publicClient,
    walletClient,
    contractAddress,
    { transferURL: '', multiWasmURL: '' },
    decryptionKey
);

Parameters

• publicClient : PublicClient
• walletClient : Wallet Client for sending transactions
• contractAddress : Address of the deployed eERC contract

• urls : { transferURL: string; multiWasmURL: string}

  • transferURL : The URL of the WebAssembly file used for generating transfer proof.

  • multiWasmURL : The URL of the WebAssembly file used for generating proofs for registration and mint operations.

• decryptionKey (optional) : string A decryption key associated with the user's account. If not provided, the decryption key can be generated during registration or using the generateDecryptionKey method.

If the Wasm files are being served locally, ensure the URLs start with / (e.g., /path/to/wasm_file.wasm). For remote files, provide the full URL (e.g., https://example.com/wasm_file.wasm). Incorrect URL formatting may prevent the Wasm modules from loading correctly.

The decryption key can be generated during the registration process or by calling the generateDecryptionKey function. However, it is essential to use a wallet created with a seed and not through an MPC or any other mechanism that generates wallets without a deterministic seed. During decryption key derivation, the user signs a predefined message. If the wallet lacks a consistent seed, the signature will vary, and the user will not be able to use the protocol correctly. Always ensure the wallet is securely and deterministically generated using a seed.

Returns

The useEERC hook returns an object containing both state variables and methods that provide full interaction with the eERC protocol.

• isInitialized: boolean Indicates whether the SDK has been initialized successfully.

• isAllDataFetched: boolean Indicates that all required data fetched from protocol.

• auditorAddress: 0x{string} Protocol auditor address.

• owner: 0x{string} Protocol owner (deployer) address.

• isRegistered: boolean Indicates whether the user is registered with the eERC protocol.

• isConverter: boolean Specifies if the eERC is converter or not.

• publicKey: bigint[] Public key of the user.

• auditorPublicKey: bigint[] Public key of the eERC auditor.

• name: string The name of the eERC token (available only in standalone mode).

• symbol: string The symbol of the eERC token (available only in standalone mode).

• shouldGenerateDecryptionKey: boolean Indicates whether the user needs to generate a decryption key.

• areYouAuditor: boolean Returns true if the current user is an auditor for the eERC contract.

• hasBeenAuditor: { isChecking: boolean; isAuditor: boolean } Tracks whether the user has been an auditor and whether it is currently being checked.

eERC transfer app only support standalone eERCs.

Methods

• register(): Promise<{key:string; transactionHash:string}> Registers the user with the eERC protocol. Only one registration per L1 is required.

  • Returns:

    • key: string - The decryption key.

    • transactionHash: string - The transaction hash for the registration.

• generateDecryptionKey(): Promise<string> Generates a decryption key for the user, set the key internally and return the key for storing later use.

• auditorDecrypt(): Promise<DecryptedTransaction[]> Decrypts encrypted transactions using the auditor's public key. If the user is not an auditor, this method will throw an error.

  • Returns an array of DecryptedTransaction

  type DecryptedTransaction = {
    type: string;
    amount: string;
    sender: `0x${string}`;
    receiver: `0x${string}` | null;
    transactionHash: `0x${string}`;
  };

• isAddressRegistered(address: string): {isRegistered: boolean; error: string } Checks if a specific address is registered with the eERC protocol.

• setContractAuditorPublicKey(address: string): Promise<{transactionHash:string}> Sets the auditor's public key for the eERC.

• useEncryptedBalance Returns a custom hook that enables encrypted operations like mint, burn and transfer privately. The following section will explain detailed usage.

Only the owner can set the auditor's public key.