@absol-labs/agent 0.7.2 → 0.8.0

package/src/wallet/autonomous-wallet.ts

@@ -1,5 +1,3 @@
-import { createPrivateKey, createPublicKey } from "node:crypto";
-
 import {
   generateAuthorizationSignature,
   generateP256KeyPair,
@@ -19,6 +17,16 @@ import {
   type AutonomousWalletProof,
   type PreparedPrivyRequest,
 } from "./autonomous-wallet-protocol.js";
+import {
+  AutonomousWalletError,
+  assertDurableCredentialStore,
+  createDefaultAutonomousWalletStore,
+  decodeBase64,
+  isRecord,
+  validateStoredRecord,
+  type AutonomousWalletCredentialStore,
+  type AutonomousWalletRecord,
+} from "./autonomous-wallet-store.js";
 
 export {
   AUTONOMOUS_WALLET_CAIP2,
@@ -29,44 +37,39 @@ export {
   type AutonomousWalletProof,
   type PreparedPrivyRequest,
 } from "./autonomous-wallet-protocol.js";
-const KEYCHAIN_SERVICE = "com.absol-labs.metrik.autonomous-wallet";
-export const METRIK_AUTONOMOUS_WALLET_BROKER_URL =
-  "https://wallet.137.23.50.249.sslip.io";
 
-export interface AutonomousWalletRecord {
-  readonly version: typeof AUTONOMOUS_WALLET_VERSION;
-  readonly appId: string;
-  readonly brokerUrl: string;
-  readonly publicKey: string;
-  /** Base64 PKCS8 P-256 key. This field must only be stored in a secure store. */
-  readonly privateKey: string;
-  readonly provisioningNonce: string;
-  readonly walletId?: string;
-  readonly address?: Address;
-  readonly policyId?: string;
-  readonly createdAt: number;
-}
+export {
+  AUTONOMOUS_WALLET_KEYCHAIN_SERVICE,
+  AutonomousWalletError,
+  InMemoryAutonomousWalletStore,
+  OsCredentialStore,
+  assertDurableCredentialStore,
+  createDefaultAutonomousWalletStore,
+  type AssertDurableCredentialStoreOptions,
+  type AutonomousWalletCredentialStore,
+  type AutonomousWalletRecord,
+  type CredentialStoreDurability,
+  type CredentialStoreDurabilityReport,
+  type OsCredentialStoreOptions,
+  type SecretEntryFactory,
+  type SecretEntryLike,
+} from "./autonomous-wallet-store.js";
 
-export interface AutonomousWalletCredentialStore {
-  load(key: string): Promise<AutonomousWalletRecord | null>;
-  save(key: string, record: AutonomousWalletRecord): Promise<void>;
-}
+export {
+  EncryptedFileCredentialStore,
+  METRIK_WALLET_ENCRYPTION_KEY_ENV,
+  METRIK_WALLET_STORE_DIR_ENV,
+  type EncryptedFileCredentialStoreOptions,
+} from "./encrypted-file-credential-store.js";
 
-export class AutonomousWalletError extends Error {
-  constructor(
-    readonly code:
-      | "invalid-config"
-      | "store-failure"
-      | "broker-failure"
-      | "proof-failure"
-      | "invalid-response",
-    message: string,
-    options?: { readonly cause?: unknown },
-  ) {
-    super(message, options);
-    this.name = "AutonomousWalletError";
-  }
-}
+export {
+  probeSecretServiceAvailable,
+  type ProbeSecretServiceOptions,
+  type SecretServiceProbeResult,
+} from "./secret-service-probe.js";
+
+export const METRIK_AUTONOMOUS_WALLET_BROKER_URL =
+  "https://wallet.137.23.50.249.sslip.io";
 
 /**
  * Wire adapter for the broker HTTP contract. The only credential sent by this
@@ -166,6 +169,13 @@ export interface ProvisionAutonomousWalletOptions {
   readonly store?: AutonomousWalletCredentialStore;
   readonly nowSeconds?: number;
   readonly nonce?: string;
+  /**
+   * Opt in to a credential store that does NOT survive a host reboot (process
+   * memory, the Linux kernel keyring). Off by default: provisioning refuses a
+   * volatile store because the owner key — and therefore any funds the wallet
+   * holds — is lost on reboot. Only set this for genuinely ephemeral runs.
+   */
+  readonly allowVolatileStore?: boolean;
 }
 
 export interface ProvisionMetrikAutonomousWalletOptions {
@@ -173,6 +183,8 @@ export interface ProvisionMetrikAutonomousWalletOptions {
   readonly brokerUrl?: string;
   readonly store?: AutonomousWalletCredentialStore;
   readonly fetchImpl?: typeof fetch;
+  /** See {@link ProvisionAutonomousWalletOptions.allowVolatileStore}. */
+  readonly allowVolatileStore?: boolean;
 }
 
 /**
@@ -223,6 +235,9 @@ export async function provisionMetrikAutonomousWallet(
     storeKey: options.storeKey,
     broker,
     ...(options.store === undefined ? {} : { store: options.store }),
+    ...(options.allowVolatileStore === undefined
+      ? {}
+      : { allowVolatileStore: options.allowVolatileStore }),
   });
 }
 
@@ -237,6 +252,11 @@ export async function provisionAutonomousWallet(
 ): Promise<AutonomousWalletRecord> {
   validateProvisionOptions(options);
   const store = options.store ?? createDefaultAutonomousWalletStore();
+  // Fail closed BEFORE a key is generated or a stored key is handed back: a
+  // volatile backend silently loses the owner key (and any funds) on reboot.
+  await assertDurableCredentialStore(store, {
+    allowVolatileStore: options.allowVolatileStore === true,
+  });
   const existingRaw = await loadRecord(store, options.storeKey);
   if (existingRaw !== null) {
     const existing = validateStoredRecord(existingRaw);
@@ -461,72 +481,6 @@ export async function createAutonomousWalletAccount(
   return createPrivyEmbeddedAccount(config);
 }
 
-export class InMemoryAutonomousWalletStore implements AutonomousWalletCredentialStore {
-  private readonly records = new Map<string, AutonomousWalletRecord>();
-
-  async load(key: string): Promise<AutonomousWalletRecord | null> {
-    return this.records.get(key) ?? null;
-  }
-
-  async save(key: string, record: AutonomousWalletRecord): Promise<void> {
-    this.records.set(key, record);
-  }
-}
-
-/**
- * Uses the host OS credential manager. There is intentionally no plaintext
- * file fallback: unsupported hosts receive an actionable error instead.
- */
-export class OsCredentialStore implements AutonomousWalletCredentialStore {
-  async load(key: string): Promise<AutonomousWalletRecord | null> {
-    const raw = await this.readSecret(key);
-    if (raw === null) return null;
-    try {
-      return validateStoredRecord(JSON.parse(raw));
-    } catch (error) {
-      throw new AutonomousWalletError(
-        "store-failure",
-        "OS credential contains invalid wallet data",
-        { cause: error },
-      );
-    }
-  }
-
-  async save(key: string, record: AutonomousWalletRecord): Promise<void> {
-    const raw = JSON.stringify(record);
-    try {
-      const { AsyncEntry } = await import("@napi-rs/keyring");
-      await new AsyncEntry(KEYCHAIN_SERVICE, key).setPassword(raw);
-      return;
-    } catch (error) {
-      throw new AutonomousWalletError(
-        "store-failure",
-        "OS credential store rejected the autonomous wallet record; no plaintext fallback is allowed",
-        { cause: error },
-      );
-    }
-  }
-
-  private async readSecret(key: string): Promise<string | null> {
-    try {
-      const { AsyncEntry } = await import("@napi-rs/keyring");
-      return (
-        (await new AsyncEntry(KEYCHAIN_SERVICE, key).getPassword()) ?? null
-      );
-    } catch (error) {
-      throw new AutonomousWalletError(
-        "store-failure",
-        "OS credential store could not read the autonomous wallet record",
-        { cause: error },
-      );
-    }
-  }
-}
-
-export function createDefaultAutonomousWalletStore(): AutonomousWalletCredentialStore {
-  return new OsCredentialStore();
-}
-
 async function loadRecord(
   store: AutonomousWalletCredentialStore,
   key: string,
@@ -612,80 +566,6 @@ function validateExistingRecord(
   }
 }
 
-function validateStoredRecord(value: unknown): AutonomousWalletRecord {
-  if (
-    !isRecord(value) ||
-    value.version !== AUTONOMOUS_WALLET_VERSION ||
-    typeof value.appId !== "string" ||
-    value.appId.trim() === "" ||
-    typeof value.brokerUrl !== "string" ||
-    typeof value.publicKey !== "string" ||
-    value.publicKey.trim() === "" ||
-    typeof value.privateKey !== "string" ||
-    value.privateKey.trim() === "" ||
-    typeof value.provisioningNonce !== "string" ||
-    value.provisioningNonce.trim() === "" ||
-    typeof value.createdAt !== "number" ||
-    !Number.isSafeInteger(value.createdAt)
-  ) {
-    throw new AutonomousWalletError(
-      "store-failure",
-      "OS credential contains an invalid autonomous wallet record",
-    );
-  }
-  if (
-    value.walletId !== undefined &&
-    (typeof value.walletId !== "string" || value.walletId.trim() === "")
-  ) {
-    throw new AutonomousWalletError(
-      "store-failure",
-      "OS credential contains an invalid wallet id",
-    );
-  }
-  if (
-    value.policyId !== undefined &&
-    (typeof value.policyId !== "string" || value.policyId.trim() === "")
-  ) {
-    throw new AutonomousWalletError(
-      "store-failure",
-      "OS credential contains an invalid policy id",
-    );
-  }
-  if (
-    value.address !== undefined &&
-    (typeof value.address !== "string" ||
-      !/^0x[0-9a-fA-F]{40}$/.test(value.address))
-  ) {
-    throw new AutonomousWalletError(
-      "store-failure",
-      "OS credential contains an invalid wallet address",
-    );
-  }
-  try {
-    validateP256KeyPair(value.publicKey, value.privateKey);
-  } catch (error) {
-    throw new AutonomousWalletError(
-      "store-failure",
-      "OS credential contains invalid P-256 key material",
-      { cause: error },
-    );
-  }
-  return {
-    version: AUTONOMOUS_WALLET_VERSION,
-    appId: value.appId,
-    brokerUrl: value.brokerUrl,
-    publicKey: value.publicKey,
-    privateKey: value.privateKey,
-    provisioningNonce: value.provisioningNonce,
-    ...(value.walletId === undefined ? {} : { walletId: value.walletId }),
-    ...(value.address === undefined
-      ? {}
-      : { address: getAddress(value.address) }),
-    ...(value.policyId === undefined ? {} : { policyId: value.policyId }),
-    createdAt: value.createdAt,
-  };
-}
-
 function normalizeBrokerUrl(value: string): string {
   const url = new URL(value);
   url.search = "";
@@ -699,49 +579,6 @@ function cryptoRandomNonce(): string {
   return Buffer.from(bytes).toString("base64url");
 }
 
-function decodeBase64(value: string): Uint8Array {
-  if (!/^[A-Za-z0-9+/]+={0,2}$/.test(value) || value.length % 4 === 1) {
-    throw new AutonomousWalletError(
-      "invalid-response",
-      "broker returned invalid proof payload encoding",
-    );
-  }
-  const decoded = Buffer.from(value, "base64");
-  if (decoded.length === 0 || decoded.toString("base64") !== value) {
-    throw new AutonomousWalletError(
-      "invalid-response",
-      "broker returned an empty proof payload",
-    );
-  }
-  return new Uint8Array(decoded);
-}
-
-function validateP256KeyPair(publicKey: string, privateKey: string): void {
-  const publicObject = createPublicKey({
-    key: Buffer.from(decodeBase64(publicKey)),
-    format: "der",
-    type: "spki",
-  });
-  const privateObject = createPrivateKey({
-    key: Buffer.from(decodeBase64(privateKey)),
-    format: "der",
-    type: "pkcs8",
-  });
-  if (
-    publicObject.asymmetricKeyType !== "ec" ||
-    publicObject.asymmetricKeyDetails?.namedCurve !== "prime256v1" ||
-    privateObject.asymmetricKeyType !== "ec" ||
-    privateObject.asymmetricKeyDetails?.namedCurve !== "prime256v1"
-  ) {
-    throw new Error("key material is not P-256");
-  }
-  const derived = createPublicKey(privateObject)
-    .export({ format: "der", type: "spki" })
-    .toString("base64");
-  if (derived !== publicKey)
-    throw new Error("public key does not match private key");
-}
-
 function validateProvisionResponse(value: unknown): {
   readonly walletId: string;
   readonly address: Address;
@@ -804,10 +641,6 @@ function validatePreparedResponse(value: unknown): PreparedPrivyRequest {
   };
 }
 
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-
 function bigintJson(_key: string, value: unknown): unknown {
   return typeof value === "bigint" ? `0x${value.toString(16)}` : value;
 }

package/src/wallet/encrypted-file-credential-store.ts

@@ -0,0 +1,341 @@
+import {
+  createCipheriv,
+  createDecipheriv,
+  createHash,
+  randomBytes,
+  scrypt,
+} from "node:crypto";
+import {
+  chmod,
+  mkdir,
+  readFile,
+  rename,
+  rm,
+  writeFile,
+} from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { promisify } from "node:util";
+
+import {
+  AutonomousWalletError,
+  isRecord,
+  validateStoredRecord,
+  type AutonomousWalletCredentialStore,
+  type AutonomousWalletRecord,
+  type CredentialStoreDurabilityReport,
+} from "./autonomous-wallet-store.js";
+
+const scryptAsync = promisify(scrypt) as (
+  secret: string | Buffer,
+  salt: Buffer,
+  keylen: number,
+  options: { readonly N: number; readonly r: number; readonly p: number },
+) => Promise<Buffer>;
+
+/** Environment variable holding the externally-managed encryption secret. */
+export const METRIK_WALLET_ENCRYPTION_KEY_ENV = "METRIK_WALLET_ENCRYPTION_KEY";
+/** Environment variable overriding where encrypted wallet files are written. */
+export const METRIK_WALLET_STORE_DIR_ENV = "METRIK_WALLET_STORE_DIR";
+
+const ENVELOPE_VERSION = 1;
+const CIPHER = "aes-256-gcm";
+const KEY_LENGTH = 32;
+const IV_LENGTH = 12;
+const SALT_LENGTH = 16;
+const SCRYPT_PARAMETERS = Object.freeze({ N: 16_384, r: 8, p: 1 });
+const MINIMUM_SECRET_LENGTH = 16;
+const FILE_MODE = 0o600;
+const DIRECTORY_MODE = 0o700;
+
+export interface EncryptedFileCredentialStoreOptions {
+  /**
+   * Directory holding one encrypted file per store key. Defaults to
+   * `$METRIK_WALLET_STORE_DIR`, else `~/.metrik/autonomous-wallets`.
+   */
+  readonly directory?: string;
+  /**
+   * Encryption secret. Defaults to `$METRIK_WALLET_ENCRYPTION_KEY`. Supply it
+   * from a platform secret manager (AWS/GCP Secrets Manager, Vault, a
+   * Docker/Kubernetes secret) — never commit it next to the encrypted file.
+   */
+  readonly encryptionKey?: string;
+  readonly env?: NodeJS.ProcessEnv;
+}
+
+interface Envelope {
+  readonly v: number;
+  readonly cipher: string;
+  readonly kdf: {
+    readonly name: "scrypt";
+    readonly N: number;
+    readonly r: number;
+    readonly p: number;
+    readonly saltBase64: string;
+  };
+  readonly ivBase64: string;
+  readonly tagBase64: string;
+  readonly ciphertextBase64: string;
+  readonly keyDigest: string;
+}
+
+/**
+ * Durable credential store for headless hosts (servers, containers, VMs, CI
+ * runners) that have no OS credential manager.
+ *
+ * The wallet record is encrypted at rest with AES-256-GCM under a key derived
+ * with scrypt from an externally-supplied secret and a fresh random salt per
+ * write; the IV is fresh per write and the ciphertext is authenticated against
+ * the store key. The secret is never written to disk, so the "no plaintext key
+ * on disk" guarantee still holds — but unlike the Linux kernel keyring the file
+ * survives a reboot, which is what a fund-controlling key requires.
+ */
+export class EncryptedFileCredentialStore implements AutonomousWalletCredentialStore {
+  private readonly directory: string;
+  private readonly secret: string;
+
+  constructor(options: EncryptedFileCredentialStoreOptions = {}) {
+    const env = options.env ?? process.env;
+    const secret =
+      options.encryptionKey ?? env[METRIK_WALLET_ENCRYPTION_KEY_ENV];
+    if (typeof secret !== "string" || secret.trim() === "") {
+      throw new AutonomousWalletError(
+        "invalid-config",
+        `EncryptedFileCredentialStore requires an encryption secret: set ${METRIK_WALLET_ENCRYPTION_KEY_ENV} (from your secret manager) or pass encryptionKey. Without it the stored wallet key cannot be decrypted.`,
+      );
+    }
+    if (secret.trim().length < MINIMUM_SECRET_LENGTH) {
+      throw new AutonomousWalletError(
+        "invalid-config",
+        `the autonomous wallet encryption secret must be at least ${MINIMUM_SECRET_LENGTH} characters; generate one with "openssl rand -base64 32"`,
+      );
+    }
+    this.secret = secret.trim();
+    this.directory =
+      options.directory ??
+      env[METRIK_WALLET_STORE_DIR_ENV] ??
+      join(homedir(), ".metrik", "autonomous-wallets");
+  }
+
+  async load(key: string): Promise<AutonomousWalletRecord | null> {
+    const path = this.pathFor(key);
+    let raw: string;
+    try {
+      raw = await readFile(path, "utf8");
+    } catch (error) {
+      if (isNotFound(error)) return null;
+      throw new AutonomousWalletError(
+        "store-failure",
+        `encrypted wallet file at ${path} could not be read`,
+        { cause: error },
+      );
+    }
+    const envelope = parseEnvelope(raw, path);
+    const digest = digestOf(key);
+    if (envelope.keyDigest !== digest) {
+      throw new AutonomousWalletError(
+        "store-failure",
+        `encrypted wallet file at ${path} belongs to a different store key`,
+      );
+    }
+    const derived = await scryptAsync(
+      this.secret,
+      Buffer.from(envelope.kdf.saltBase64, "base64"),
+      KEY_LENGTH,
+      { N: envelope.kdf.N, r: envelope.kdf.r, p: envelope.kdf.p },
+    );
+    let plaintext: string;
+    try {
+      const decipher = createDecipheriv(
+        CIPHER,
+        derived,
+        Buffer.from(envelope.ivBase64, "base64"),
+      );
+      decipher.setAAD(additionalData(digest));
+      decipher.setAuthTag(Buffer.from(envelope.tagBase64, "base64"));
+      plaintext = Buffer.concat([
+        decipher.update(Buffer.from(envelope.ciphertextBase64, "base64")),
+        decipher.final(),
+      ]).toString("utf8");
+    } catch (error) {
+      throw new AutonomousWalletError(
+        "store-failure",
+        `encrypted wallet file at ${path} failed authenticated decryption: the ${METRIK_WALLET_ENCRYPTION_KEY_ENV} secret does not match the one used to write it, or the file was modified. Restore the original secret; the wallet key cannot be recovered without it.`,
+        { cause: error },
+      );
+    }
+    try {
+      return validateStoredRecord(JSON.parse(plaintext));
+    } catch (error) {
+      if (error instanceof AutonomousWalletError) throw error;
+      throw new AutonomousWalletError(
+        "store-failure",
+        `encrypted wallet file at ${path} contains invalid wallet data`,
+        { cause: error },
+      );
+    }
+  }
+
+  async save(key: string, record: AutonomousWalletRecord): Promise<void> {
+    const path = this.pathFor(key);
+    const digest = digestOf(key);
+    try {
+      await mkdir(this.directory, { recursive: true, mode: DIRECTORY_MODE });
+      const salt = randomBytes(SALT_LENGTH);
+      const iv = randomBytes(IV_LENGTH);
+      const derived = await scryptAsync(
+        this.secret,
+        salt,
+        KEY_LENGTH,
+        SCRYPT_PARAMETERS,
+      );
+      const cipher = createCipheriv(CIPHER, derived, iv);
+      cipher.setAAD(additionalData(digest));
+      const ciphertext = Buffer.concat([
+        cipher.update(Buffer.from(JSON.stringify(record), "utf8")),
+        cipher.final(),
+      ]);
+      const envelope: Envelope = {
+        v: ENVELOPE_VERSION,
+        cipher: CIPHER,
+        kdf: {
+          name: "scrypt",
+          ...SCRYPT_PARAMETERS,
+          saltBase64: salt.toString("base64"),
+        },
+        ivBase64: iv.toString("base64"),
+        tagBase64: cipher.getAuthTag().toString("base64"),
+        ciphertextBase64: ciphertext.toString("base64"),
+        keyDigest: digest,
+      };
+      const temporaryPath = `${path}.${randomBytes(6).toString("hex")}.tmp`;
+      await writeFile(temporaryPath, JSON.stringify(envelope), {
+        mode: FILE_MODE,
+      });
+      // writeFile's mode is subject to the process umask; force 0600.
+      await chmod(temporaryPath, FILE_MODE);
+      await rename(temporaryPath, path);
+      await chmod(path, FILE_MODE);
+    } catch (error) {
+      throw new AutonomousWalletError(
+        "store-failure",
+        `encrypted wallet file at ${path} could not be written`,
+        { cause: error },
+      );
+    }
+  }
+
+  async probeDurability(): Promise<CredentialStoreDurabilityReport> {
+    const probePath = join(
+      this.directory,
+      `.durability-probe-${randomBytes(6).toString("hex")}`,
+    );
+    try {
+      await mkdir(this.directory, { recursive: true, mode: DIRECTORY_MODE });
+      await writeFile(probePath, "metrik-durability-probe", {
+        mode: FILE_MODE,
+      });
+      const observed = await readFile(probePath, "utf8");
+      if (observed !== "metrik-durability-probe") {
+        return {
+          durability: "volatile",
+          backend: "encrypted-file",
+          detail: `the probe file at ${this.directory} did not read back with the value written`,
+        };
+      }
+      return {
+        durability: "durable",
+        backend: "encrypted-file",
+        detail: `AES-256-GCM encrypted files under ${this.directory} persist across reboots; the key is derived from ${METRIK_WALLET_ENCRYPTION_KEY_ENV}, which you must keep in your secret manager`,
+      };
+    } catch (error) {
+      return {
+        durability: "volatile",
+        backend: "encrypted-file",
+        detail: `${this.directory} is not writable: ${error instanceof Error ? error.message : String(error)}`,
+      };
+    } finally {
+      await rm(probePath, { force: true }).catch(() => undefined);
+    }
+  }
+
+  /** Absolute path of the encrypted file backing `key`. */
+  pathFor(key: string): string {
+    if (key.trim() === "") {
+      throw new AutonomousWalletError(
+        "invalid-config",
+        "secure store key is required",
+      );
+    }
+    // Hash the key so an arbitrary store key can never traverse the directory.
+    return join(this.directory, `${digestOf(key)}.metrik-wallet.json`);
+  }
+}
+
+function additionalData(keyDigest: string): Buffer {
+  return Buffer.from(
+    `metrik-autonomous-wallet-v${ENVELOPE_VERSION}:${keyDigest}`,
+    "utf8",
+  );
+}
+
+function digestOf(key: string): string {
+  return createHash("sha256").update(key, "utf8").digest("hex");
+}
+
+function isNotFound(error: unknown): boolean {
+  return (
+    typeof error === "object" &&
+    error !== null &&
+    (error as { readonly code?: unknown }).code === "ENOENT"
+  );
+}
+
+function parseEnvelope(raw: string, path: string): Envelope {
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (error) {
+    throw new AutonomousWalletError(
+      "store-failure",
+      `encrypted wallet file at ${path} is not valid JSON`,
+      { cause: error },
+    );
+  }
+  const kdf = isRecord(parsed) ? parsed.kdf : undefined;
+  if (
+    !isRecord(parsed) ||
+    parsed.v !== ENVELOPE_VERSION ||
+    parsed.cipher !== CIPHER ||
+    typeof parsed.ivBase64 !== "string" ||
+    typeof parsed.tagBase64 !== "string" ||
+    typeof parsed.ciphertextBase64 !== "string" ||
+    typeof parsed.keyDigest !== "string" ||
+    !isRecord(kdf) ||
+    kdf.name !== "scrypt" ||
+    typeof kdf.N !== "number" ||
+    typeof kdf.r !== "number" ||
+    typeof kdf.p !== "number" ||
+    typeof kdf.saltBase64 !== "string"
+  ) {
+    throw new AutonomousWalletError(
+      "store-failure",
+      `encrypted wallet file at ${path} has an unsupported envelope`,
+    );
+  }
+  return {
+    v: ENVELOPE_VERSION,
+    cipher: CIPHER,
+    kdf: {
+      name: "scrypt",
+      N: kdf.N,
+      r: kdf.r,
+      p: kdf.p,
+      saltBase64: kdf.saltBase64,
+    },
+    ivBase64: parsed.ivBase64,
+    tagBase64: parsed.tagBase64,
+    ciphertextBase64: parsed.ciphertextBase64,
+    keyDigest: parsed.keyDigest,
+  };
+}