iwa 0.0.1a2__py3-none-any.whl → 0.0.1a4__py3-none-any.whl

iwa/core/contracts/abis/multisend.json

@@ -0,0 +1,24 @@
+[
+    {
+       "inputs":[
+
+       ],
+       "stateMutability":"nonpayable",
+       "type":"constructor"
+    },
+    {
+       "inputs":[
+          {
+             "internalType":"bytes",
+             "name":"transactions",
+             "type":"bytes"
+          }
+       ],
+       "name":"multiSend",
+       "outputs":[
+
+       ],
+       "stateMutability":"payable",
+       "type":"function"
+    }
+ ]

iwa/core/contracts/abis/multisend_call_only.json

@@ -0,0 +1,17 @@
+[
+    {
+       "inputs":[
+          {
+             "internalType":"bytes",
+             "name":"transactions",
+             "type":"bytes"
+          }
+       ],
+       "name":"multiSend",
+       "outputs":[
+
+       ],
+       "stateMutability":"payable",
+       "type":"function"
+    }
+ ]

iwa/core/contracts/contract.py

@@ -54,11 +54,20 @@ class ContractInstance:
             else:
                 self.abi = contract_abi
 
-        self.contract: Contract = self.chain_interface.web3.eth.contract(
-            address=self.address, abi=self.abi
-        )
+        self._contract_cache = None
         self.error_selectors = self.load_error_selectors()
 
+    @property
+    def contract(self) -> Contract:
+        """Get contract instance using the current Web3 provider.
+
+        This property ensures that after an RPC rotation, contract calls
+        use the updated provider instead of the original one.
+        """
+        # Always create a fresh contract to use the current Web3 provider
+        # This is necessary because RPC rotation changes the underlying provider
+        return self.chain_interface.web3.eth.contract(address=self.address, abi=self.abi)
+
     def load_error_selectors(self) -> Dict[str, Any]:
         """Load error selectors from the contract ABI."""
         selectors = {}
@@ -183,7 +192,10 @@ class ContractInstance:
         """
         method = getattr(self.contract.functions, method_name)
         try:
-            return method(*args).call()
+            return self.chain_interface.with_retry(
+                lambda: method(*args).call(),
+                operation_name=f"call {method_name} on {self.name}",
+            )
         except Exception as e:
             error_data = self._extract_error_data(e)
             if error_data:

iwa/core/ipfs.py

@@ -0,0 +1,149 @@
+"""IPFS utilities for pushing and retrieving data.
+
+This module provides functionality to push metadata to IPFS using
+direct HTTP API calls, avoiding heavy dependencies like open-aea.
+"""
+
+import hashlib
+import json
+import uuid
+from typing import Any, Dict, Optional, Tuple
+
+import aiohttp
+from multiformats import CID
+
+from iwa.core.models import Config
+
+
+def _compute_cid_v1_hex(data: bytes) -> str:
+    """Compute CIDv1 hex representation from raw data.
+
+    This creates a CIDv1 with:
+    - multibase: 'f' (base16 lowercase)
+    - version: 1
+    - codec: raw (0x55)
+    - multihash: sha2-256
+
+    :param data: The raw data bytes.
+    :return: The CIDv1 as hex string (f01...).
+    """
+    # SHA-256 hash
+    digest = hashlib.sha256(data).digest()
+
+    # Build CIDv1: raw codec (0x55), sha2-256 multihash (0x12), 32 bytes length (0x20)
+    cid = CID("base16", 1, "raw", ("sha2-256", digest))
+    return str(cid)
+
+
+async def push_to_ipfs_async(
+    data: bytes,
+    api_url: Optional[str] = None,
+    pin: bool = True,
+) -> Tuple[str, str]:
+    """Push raw data to IPFS using the HTTP API.
+
+    :param data: The data bytes to push.
+    :param api_url: Optional IPFS API URL. Defaults to IPFS_API_URL env var or localhost.
+    :param pin: Whether to pin the content (default True).
+    :return: Tuple of (CIDv1 string, CIDv1 hex representation).
+    """
+    url = api_url or Config().core.ipfs_api_url
+    endpoint = f"{url}/api/v0/add"
+
+    params = {"pin": str(pin).lower(), "cid-version": "1"}
+
+    # Create multipart form data
+    form = aiohttp.FormData()
+    form.add_field("file", data, filename="data", content_type="application/octet-stream")
+
+    async with aiohttp.ClientSession() as session:
+        async with session.post(endpoint, data=form, params=params) as response:
+            response.raise_for_status()
+            result = await response.json()
+
+    cid_str = result["Hash"]
+    cid = CID.decode(cid_str)
+
+    # Convert to hex representation (f01 prefix for base16 + CIDv1)
+    # We need to reconstruct with the multihash as a tuple (name, digest)
+    cid_hex = str(CID("base16", cid.version, cid.codec, (cid.hashfun.name, cid.raw_digest)))
+
+    return cid_str, cid_hex
+
+
+def push_to_ipfs_sync(
+    data: bytes,
+    api_url: Optional[str] = None,
+    pin: bool = True,
+) -> Tuple[str, str]:
+    """Push raw data to IPFS using the HTTP API (synchronous version).
+
+    :param data: The data bytes to push.
+    :param api_url: Optional IPFS API URL. Defaults to IPFS_API_URL env var or localhost.
+    :param pin: Whether to pin the content (default True).
+    :return: Tuple of (CIDv1 string, CIDv1 hex representation).
+    """
+    import requests
+
+    url = api_url or Config().core.ipfs_api_url
+    endpoint = f"{url}/api/v0/add"
+
+    params = {"pin": str(pin).lower(), "cid-version": "1"}
+
+    files = {"file": ("data", data, "application/octet-stream")}
+
+    response = requests.post(endpoint, files=files, params=params, timeout=60)
+    response.raise_for_status()
+    result = response.json()
+
+    cid_str = result["Hash"]
+    cid = CID.decode(cid_str)
+
+    # Convert to hex representation (f01 prefix for base16 + CIDv1)
+    # We need to reconstruct with the multihash as a tuple (name, digest)
+    cid_hex = str(CID("base16", cid.version, cid.codec, (cid.hashfun.name, cid.raw_digest)))
+
+    return cid_str, cid_hex
+
+
+def push_metadata_to_ipfs(
+    metadata: Dict[str, Any],
+    extra_attributes: Optional[Dict[str, Any]] = None,
+    api_url: Optional[str] = None,
+) -> Tuple[str, str]:
+    """Push a metadata dict to IPFS synchronously.
+
+    A unique nonce is added automatically to ensure uniqueness.
+
+    :param metadata: Metadata dictionary to push.
+    :param extra_attributes: Extra attributes to include in the metadata.
+    :param api_url: Optional IPFS API URL.
+    :return: Tuple of (truncated hash with 0x prefix for contract calls, full CID hex).
+    """
+    data = {**metadata, "nonce": str(uuid.uuid4())}
+    if extra_attributes:
+        data.update(extra_attributes)
+
+    json_bytes = json.dumps(data, separators=(",", ":")).encode("utf-8")
+    _, cid_hex = push_to_ipfs_sync(json_bytes, api_url)
+
+    # The truncated hash format expected by mech contracts: 0x + hex after the f01 prefix
+    # CIDv1 hex format: f01{codec}{multihash} -> we want just the multihash part
+    # For compatibility with triton, we return "0x" + cid_hex[9:] (skip f01 + 2-byte codec)
+    truncated_hash = "0x" + cid_hex[9:]
+
+    return truncated_hash, cid_hex
+
+
+def metadata_to_request_data(
+    metadata: Dict[str, Any],
+    api_url: Optional[str] = None,
+) -> bytes:
+    """Convert a metadata dict to mech request data by pushing to IPFS.
+
+    :param metadata: Metadata dictionary (typically contains 'prompt', 'tool', etc.).
+    :param api_url: Optional IPFS API URL.
+    :return: The request data as bytes (truncated IPFS hash).
+    """
+    truncated_hash, _ = push_metadata_to_ipfs(metadata, api_url=api_url)
+    return bytes.fromhex(truncated_hash[2:])

iwa/core/keys.py

@@ -4,55 +4,113 @@ import base64
 import json
 import os
 import shutil
+import sys
 from datetime import datetime
 from pathlib import Path
-from typing import Dict, Optional, Union
-
+from typing import Any, Dict, Optional, Tuple, Union
+
+from bip_utils import (
+    Bip39MnemonicGenerator,
+    Bip39SeedGenerator,
+    Bip39WordsNum,
+    Bip44,
+    Bip44Changes,
+    Bip44Coins,
+)
 from cryptography.hazmat.primitives.ciphers.aead import AESGCM
 from cryptography.hazmat.primitives.kdf.scrypt import Scrypt
 from eth_account import Account
 from eth_account.signers.local import LocalAccount
-from pydantic import BaseModel, PrivateAttr
+from pydantic import BaseModel, PrivateAttr, model_validator
 
 from iwa.core.constants import WALLET_PATH
-from iwa.core.models import EthereumAddress, StoredAccount, StoredSafeAccount
-from iwa.core.settings import settings
+from iwa.core.models import EncryptedData, EthereumAddress, StoredAccount, StoredSafeAccount
+from iwa.core.secrets import secrets
 from iwa.core.utils import (
     configure_logger,
 )
 
 logger = configure_logger()
 
+# Mnemonic constants
+MNEMONIC_WORD_NUMBER = Bip39WordsNum.WORDS_NUM_24
+SCRYPT_N = 2**14
+SCRYPT_R = 8
+SCRYPT_P = 1
+SCRYPT_LEN = 32
+AES_NONCE_LEN = 12
+SALT_LEN = 16
+
 
-class EncryptedAccount(StoredAccount):
+class EncryptedAccount(StoredAccount, EncryptedData):
     """EncryptedAccount"""
 
-    salt: str
-    nonce: str
-    ciphertext: str
+    # We do NOT define 'salt' here to avoid serialization duplication.
+    # Legacy 'salt' is handled in the validator.
+
+    @model_validator(mode="before")
+    @classmethod
+    def upgrade_legacy_format(cls, data: Dict[str, Any]) -> Dict[str, Any]:
+        """Upgrade legacy account format to new EncryptedData structure."""
+        if isinstance(data, dict):
+            # Check if this is a legacy format (has 'salt')
+            if "salt" in data:
+                # Map to kdf_salt if missing
+                if "kdf_salt" not in data:
+                    data["kdf_salt"] = data["salt"]
+
+                # Remove 'salt' to avoid "extra fields" error and duplication
+                data.pop("salt")
+
+                # Default KDF params for legacy accounts were:
+                # n=2**14 (16384), r=8, p=1, len=32
+                data.setdefault("kdf_n", SCRYPT_N)
+                data.setdefault("kdf_r", SCRYPT_R)
+                data.setdefault("kdf_p", SCRYPT_P)
+                data.setdefault("kdf_len", SCRYPT_LEN)
+                data.setdefault("kdf", "scrypt")
+                data.setdefault("cipher", "aesgcm")
+        return data
 
     @staticmethod
-    def derive_key(password: str, salt: bytes) -> bytes:
+    def derive_key(
+        password: str,
+        salt: bytes,
+        n: int = SCRYPT_N,
+        r: int = SCRYPT_R,
+        p: int = SCRYPT_P,
+        length: int = SCRYPT_LEN,
+    ) -> bytes:
         """Derive key"""
         kdf = Scrypt(
             salt=salt,
-            length=32,
-            n=2**14,
-            r=8,
-            p=1,
+            length=length,
+            n=n,
+            r=r,
+            p=p,
         )
         return kdf.derive(password.encode())
 
     def decrypt_private_key(self, password: Optional[str] = None) -> str:
         """decrypt_private_key"""
-        if not password and not settings.wallet_password:
+        if not password and not secrets.wallet_password:
             raise ValueError("Password must be provided or set in secrets.env (WALLET_PASSWORD)")
         if not password:
-            password = settings.wallet_password.get_secret_value()
-        salt_bytes = base64.b64decode(self.salt)
+            password = secrets.wallet_password.get_secret_value()
+
+        # Use kdf_salt (populated by upgrade_legacy_format if needed)
+        salt_bytes = base64.b64decode(self.kdf_salt)
         nonce_bytes = base64.b64decode(self.nonce)
         ciphertext_bytes = base64.b64decode(self.ciphertext)
-        key = EncryptedAccount.derive_key(password, salt_bytes)
+
+        key = EncryptedAccount.derive_key(
+            password,
+            salt_bytes,
+            n=self.kdf_n,
+            r=self.kdf_r,
+            p=self.kdf_p,
+            length=self.kdf_len,
+        )
         aesgcm = AESGCM(key)
         return aesgcm.decrypt(nonce_bytes, ciphertext_bytes, None).decode()
 
@@ -61,19 +119,36 @@ class EncryptedAccount(StoredAccount):
         private_key: str, password: str, tag: Optional[str] = None
     ) -> "EncryptedAccount":
         """Encrypt private key"""
-        salt = os.urandom(16)
-        key = EncryptedAccount.derive_key(password, salt)
+        # Generate new random salt
+        salt = os.urandom(SALT_LEN)
+
+        # Use standard constants for new encryptions
+        kdf_n = SCRYPT_N
+        kdf_r = SCRYPT_R
+        kdf_p = SCRYPT_P
+        kdf_len = SCRYPT_LEN
+
+        key = EncryptedAccount.derive_key(password, salt, n=kdf_n, r=kdf_r, p=kdf_p, length=kdf_len)
         aesgcm = AESGCM(key)
-        nonce = os.urandom(12)
+        nonce = os.urandom(AES_NONCE_LEN)
         ciphertext = aesgcm.encrypt(nonce, private_key.encode(), None)
 
         acct = Account.from_key(private_key)
+
         return EncryptedAccount(
             address=acct.address,
-            salt=base64.b64encode(salt).decode(),
-            nonce=base64.b64encode(nonce).decode(),
-            ciphertext=base64.b64encode(ciphertext).decode(),
-            tag=tag,
+            tag=tag or "",
+            # EncryptedData fields
+            kdf="scrypt",
+            kdf_salt=base64.b64encode(salt).decode("utf-8"),
+            kdf_n=kdf_n,
+            kdf_r=kdf_r,
+            kdf_p=kdf_p,
+            kdf_len=kdf_len,
+            cipher="aesgcm",
+            nonce=base64.b64encode(nonce).decode("utf-8"),
+            ciphertext=base64.b64encode(ciphertext).decode("utf-8"),
+            # NO redundant 'salt' field
         )
 
 
@@ -81,8 +156,10 @@ class KeyStorage(BaseModel):
     """KeyStorage"""
 
     accounts: Dict[EthereumAddress, Union[EncryptedAccount, StoredSafeAccount]] = {}
+    encrypted_mnemonic: Optional[dict] = None  # Encrypted BIP-39 mnemonic for master
     _path: Path = PrivateAttr()  # not stored nor validated
     _password: str = PrivateAttr()
+    _pending_mnemonic: Optional[str] = PrivateAttr(default=None)  # Temp storage for display
 
     def __init__(self, path: Path = Path(WALLET_PATH), password: Optional[str] = None):
         """Initialize key storage."""
@@ -109,7 +186,7 @@ class KeyStorage(BaseModel):
 
         self._path = path
         if password is None:
-            password = settings.wallet_password.get_secret_value()
+            password = secrets.wallet_password.get_secret_value()
         self._password = password
 
         if os.path.exists(path):
@@ -117,9 +194,12 @@ class KeyStorage(BaseModel):
                 with open(path, "r") as f:
                     data = json.load(f)
                     self.accounts = {
-                        k: EncryptedAccount(**v) if "signers" not in v else StoredSafeAccount(**v)
+                        EthereumAddress(k): EncryptedAccount(**v)
+                        if "signers" not in v
+                        else StoredSafeAccount(**v)
                         for k, v in data.get("accounts", {}).items()
                     }
+                    self.encrypted_mnemonic = data.get("encrypted_mnemonic")
             except json.JSONDecodeError:
                 logger.error(f"Failed to load wallet from {path}: File is corrupted.")
                 self.accounts = {}
@@ -165,21 +245,171 @@ class KeyStorage(BaseModel):
         # Enforce read/write only for the owner
         os.chmod(self._path, 0o600)
 
+    @staticmethod
+    def _encrypt_mnemonic(mnemonic: str, password: str) -> dict:
+        """Encrypt a mnemonic with AES-GCM using a scrypt-derived key."""
+        password_b = password.encode("utf-8")
+        salt = os.urandom(SALT_LEN)
+        kdf = Scrypt(salt=salt, length=SCRYPT_LEN, n=SCRYPT_N, r=SCRYPT_R, p=SCRYPT_P)
+        key = kdf.derive(password_b)
+        aesgcm = AESGCM(key)
+        nonce = os.urandom(AES_NONCE_LEN)
+        ct = aesgcm.encrypt(nonce, mnemonic.encode("utf-8"), None)
+        return {
+            "kdf": "scrypt",
+            "kdf_salt": base64.b64encode(salt).decode(),
+            "kdf_n": SCRYPT_N,
+            "kdf_r": SCRYPT_R,
+            "kdf_p": SCRYPT_P,
+            "kdf_len": SCRYPT_LEN,
+            "cipher": "aesgcm",
+            "nonce": base64.b64encode(nonce).decode(),
+            "ciphertext": base64.b64encode(ct).decode(),
+        }
+
+    @staticmethod
+    def _decrypt_mnemonic(encobj: dict, password: str) -> str:
+        """Decrypt a mnemonic previously created by `_encrypt_mnemonic`."""
+        if encobj.get("kdf") != "scrypt":
+            raise ValueError(f"Unsupported kdf: {encobj.get('kdf')}")
+        if encobj.get("cipher") != "aesgcm":
+            raise ValueError(f"Unsupported cipher: {encobj.get('cipher')}")
+
+        salt = base64.b64decode(encobj["kdf_salt"])
+        nonce = base64.b64decode(encobj["nonce"])
+        ct = base64.b64decode(encobj["ciphertext"])
+
+        n = encobj.get("kdf_n", SCRYPT_N)
+        r = encobj.get("kdf_r", SCRYPT_R)
+        p = encobj.get("kdf_p", SCRYPT_P)
+        length = encobj.get("kdf_len", SCRYPT_LEN)
+
+        kdf = Scrypt(salt=salt, length=length, n=n, r=r, p=p)
+        key = kdf.derive(password.encode("utf-8"))
+        aesgcm = AESGCM(key)
+        pt = aesgcm.decrypt(nonce, ct, None)
+        return pt.decode("utf-8")
+
+    def decrypt_mnemonic(self) -> str:
+        """Decrypt the stored mnemonic using the wallet password."""
+        if not self.encrypted_mnemonic:
+            raise ValueError("No encrypted mnemonic found in wallet.")
+        return self._decrypt_mnemonic(self.encrypted_mnemonic, self._password)
+
+    @staticmethod
+    def _derive_private_key_from_mnemonic(mnemonic: str, index: int = 0) -> str:
+        """Derive ETH private key from mnemonic using BIP-44 path."""
+        seed_bytes = Bip39SeedGenerator(mnemonic).Generate()
+        bip44_ctx = Bip44.FromSeed(seed_bytes, Bip44Coins.ETHEREUM)
+        addr_ctx = (
+            bip44_ctx.Purpose().Coin().Account(0).Change(Bip44Changes.CHAIN_EXT).AddressIndex(index)
+        )
+        return addr_ctx.PrivateKey().Raw().ToHex()
+
+    def _create_master_from_mnemonic(self) -> Tuple[EncryptedAccount, str]:
+        """Create master account from a new BIP-39 mnemonic.
+
+        Returns:
+            Tuple of (EncryptedAccount, plaintext_mnemonic).
+            The mnemonic should be shown to user ONCE and never stored in plaintext.
+
+        """
+        # Generate 24-word mnemonic
+        mnemonic = Bip39MnemonicGenerator().FromWordsNumber(MNEMONIC_WORD_NUMBER)
+        mnemonic_str = mnemonic.ToStr()
+
+        # Derive first account (index 0)
+        private_key_hex = self._derive_private_key_from_mnemonic(mnemonic_str, 0)
+
+        # Encrypt mnemonic for storage
+        self.encrypted_mnemonic = self._encrypt_mnemonic(mnemonic_str, self._password)
+
+        # Encrypt private key and create account
+        encrypted_acct = EncryptedAccount.encrypt_private_key(
+            private_key_hex, self._password, "master"
+        )
+        self.accounts[encrypted_acct.address] = encrypted_acct
+        self.save()
+
+        return encrypted_acct, mnemonic_str
+
     def create_account(self, tag: str) -> EncryptedAccount:
-        """Create account"""
+        """Create account. Master is derived from mnemonic, others are random."""
         tags = [acct.tag for acct in self.accounts.values()]
         if not tags:
             tag = "master"  # First account is always master
         if tag in tags:
             raise ValueError(f"Tag '{tag}' already exists in wallet.")
 
-        acct = Account.create()
+        # Master account: derive from mnemonic
+        if tag == "master":
+            encrypted_acct, mnemonic = self._create_master_from_mnemonic()
+            self._pending_mnemonic = mnemonic  # Store temporarily for display
+            return encrypted_acct
 
+        # Non-master: random key as before
+        acct = Account.create()
         encrypted = EncryptedAccount.encrypt_private_key(acct.key.hex(), self._password, tag)
         self.accounts[acct.address] = encrypted
         self.save()
         return encrypted
 
+    def get_pending_mnemonic(self) -> Optional[str]:
+        """Get and clear the pending mnemonic (for one-time display).
+
+        Returns:
+            The mnemonic string if available, None otherwise.
+            Clears the pending mnemonic after returning.
+
+        """
+        mnemonic = self._pending_mnemonic
+        self._pending_mnemonic = None
+        return mnemonic
+
+    def display_pending_mnemonic(self) -> bool:
+        """Display the pending mnemonic to the user and wait for confirmation.
+
+        Returns:
+            True if a mnemonic was displayed, False otherwise.
+
+        """
+        # SECURITY: Do NOT print mnemonic if not in an interactive terminal (avoids Docker logs)
+        if not sys.stdout.isatty():
+            if self._pending_mnemonic:
+                print("\n" + "!" * 60)
+                print("⚠️  SECURITY WARNING: MASTER ACCOUNT CREATED FROM MNEMONIC")
+                print("!" * 60)
+                print("\nSince this is a non-interactive terminal (e.g. Docker background),")
+                print("the mnemonic is NOT displayed here to prevent it from being")
+                print("stored in log files.")
+                print("\nTo view and backup your mnemonic, run:")
+                print("  just mnemonic")
+                print("!" * 60 + "\n")
+            return False
+
+        mnemonic = self.get_pending_mnemonic()
+        if not mnemonic:
+            return False
+
+        print("\n" + "=" * 60)
+        print("⚠️  NEW MASTER ACCOUNT CREATED - BACKUP YOUR MNEMONIC!")
+        print("=" * 60)
+        print("\nWrite down these 24 words and store them in a safe place.")
+        print("This is the ONLY time they will be shown.\n")
+        print("-" * 60)
+        words = mnemonic.split()
+        for i in range(0, 24, 4):
+            print(
+                f"  {i + 1:2}. {words[i]:12}  {i + 2:2}. {words[i + 1]:12}  "
+                f"{i + 3:2}. {words[i + 2]:12}  {i + 4:2}. {words[i + 3]:12}"
+            )
+        print("-" * 60)
+        print("\n⚠️  If you lose this mnemonic, you CANNOT recover your funds!")
+        print("=" * 60)
+        input("\nPress ENTER after you have saved your mnemonic...")
+        print()
+        return True
+
     def remove_account(self, address_or_tag: str):
         """Remove account"""
         account = self.find_stored_account(address_or_tag)

iwa/core/mnemonic.py

@@ -21,7 +21,7 @@ from eth_account import Account
 from pydantic import BaseModel
 
 from iwa.core.constants import WALLET_PATH
-from iwa.core.models import EthereumAddress, StoredAccount
+from iwa.core.models import EncryptedData, EthereumAddress, StoredAccount
 
 MNEMONIC_WORD_NUMBER = Bip39WordsNum.WORDS_NUM_24
 SCRYPT_N = 2**14
@@ -32,19 +32,9 @@ AES_NONCE_LEN = 12
 SALT_LEN = 16
 
 
-class EncryptedMnemonic(BaseModel):
+class EncryptedMnemonic(EncryptedData):
     """EncryptedMnemonic"""
 
-    kdf: str = "scrypt"
-    kdf_salt: str
-    kdf_n: int = SCRYPT_N
-    kdf_r: int = SCRYPT_R
-    kdf_p: int = SCRYPT_P
-    kdf_len: int = SCRYPT_LEN
-    cypher: str = "aesgcm"
-    nonce: str
-    ciphertext: str
-
     def derive_key(self, password: bytes) -> bytes:
         """Derive a key from a password and salt using scrypt."""
         kdf = Scrypt(
@@ -61,7 +51,7 @@ class EncryptedMnemonic(BaseModel):
         # validate expected algorithms
         if self.kdf != "scrypt":
             raise ValueError(f"Unsupported kdf: {self.kdf}")
-        if self.cypher != "aesgcm":
+        if self.cipher != "aesgcm":
             raise ValueError("Unsupported cipher, expected 'aesgcm'")
 
         nonce = base64.b64decode(self.nonce)