@vapi-network/core 0.7.0 → 0.8.0

package/dist/secrets.js

@@ -2212,7 +2212,7 @@ function weierstrass(curveDef) {
   function prepSig(msgHash, privateKey, opts = defaultSigOpts) {
     if (["recovered", "canonical"].some((k) => k in opts))
       throw new Error("sign() legacy options not supported");
-    const { hash: hash2, randomBytes: randomBytes4 } = CURVE;
+    const { hash: hash2, randomBytes: randomBytes5 } = CURVE;
     let { lowS, prehash, extraEntropy: ent } = opts;
     if (lowS == null)
       lowS = true;
@@ -2224,7 +2224,7 @@ function weierstrass(curveDef) {
     const d = normPrivateKeyToScalar(privateKey);
     const seedArgs = [int2octets(d), int2octets(h1int)];
     if (ent != null && ent !== false) {
-      const e2 = ent === true ? randomBytes4(Fp.BYTES) : ent;
+      const e2 = ent === true ? randomBytes5(Fp.BYTES) : ent;
       seedArgs.push(ensureBytes("extraEntropy", e2));
     }
     const seed = concatBytes2(...seedArgs);
@@ -2793,16 +2793,16 @@ function hexToBytes3(hex_, opts = {}) {
     assertSize(hex3, { size: opts.size });
     hex3 = pad(hex3, { dir: "right", size: opts.size });
   }
-  let hexString = hex3.slice(2);
-  if (hexString.length % 2)
-    hexString = `0${hexString}`;
-  const length = hexString.length / 2;
+  let hexString2 = hex3.slice(2);
+  if (hexString2.length % 2)
+    hexString2 = `0${hexString2}`;
+  const length = hexString2.length / 2;
   const bytes = new Uint8Array(length);
   for (let index = 0, j = 0; index < length; index++) {
-    const nibbleLeft = charCodeToBase16(hexString.charCodeAt(j++));
-    const nibbleRight = charCodeToBase16(hexString.charCodeAt(j++));
+    const nibbleLeft = charCodeToBase16(hexString2.charCodeAt(j++));
+    const nibbleRight = charCodeToBase16(hexString2.charCodeAt(j++));
     if (nibbleLeft === void 0 || nibbleRight === void 0) {
-      throw new BaseError(`Invalid byte sequence ("${hexString[j - 2]}${hexString[j - 1]}" in "${hexString}").`);
+      throw new BaseError(`Invalid byte sequence ("${hexString2[j - 2]}${hexString2[j - 1]}" in "${hexString2}").`);
     }
     bytes[index] = nibbleLeft * 16 + nibbleRight;
   }
@@ -4273,9 +4273,9 @@ var init_stringify = __esm({
 });
 
 // src/keystore.ts
-import { createCipheriv, createDecipheriv, randomBytes as randomBytes2, scrypt } from "node:crypto";
-import { mkdir as mkdir2, readFile as readFile2, rename as rename2, stat as stat2, writeFile as writeFile2 } from "node:fs/promises";
-import { dirname as dirname2 } from "node:path";
+import { createCipheriv, createDecipheriv, randomBytes as randomBytes3, scrypt } from "node:crypto";
+import { mkdir as mkdir3, readFile as readFile3, rename as rename3, stat as stat3, writeFile as writeFile2 } from "node:fs/promises";
+import { dirname as dirname3 } from "node:path";
 
 // ../../node_modules/.pnpm/@solana+errors@5.5.1_typescript@6.0.3/node_modules/@solana/errors/dist/index.node.mjs
 var SOLANA_ERROR__BLOCK_HEIGHT_EXCEEDED = 1;
@@ -46542,13 +46542,232 @@ function date4(params) {
 
 // src/config.ts
 import { constants } from "node:fs";
-import { copyFile, mkdir, readFile, rename, stat, writeFile } from "node:fs/promises";
+import { copyFile, mkdir as mkdir2, readFile as readFile2, rename as rename2, stat as stat2, writeFile } from "node:fs/promises";
 import { homedir } from "node:os";
-import { dirname, join as join2 } from "node:path";
+import { dirname as dirname2, join as join3 } from "node:path";
 
 // ../../node_modules/.pnpm/viem@2.56.1_typescript@6.0.3_zod@4.5.4/node_modules/viem/_esm/index.js
 init_getAddress();
 
+// src/atomic-file.ts
+import { randomBytes as randomBytes2 } from "node:crypto";
+import { link, mkdir, open as open2, readdir, readFile, rename, stat, unlink } from "node:fs/promises";
+import { basename, dirname, join as join2 } from "node:path";
+var DEFAULT_LOCK_TIMEOUT_MS = 2e3;
+var LOCK_RETRY_MS = 20;
+var LOCK_STALE_AFTER_MS = 12e4;
+var LOCK_HEARTBEAT_MS = 3e4;
+var atomicFileTestHooks;
+var FileLockedError = class extends Error {
+  constructor(message = "Timed out waiting for the file lock.") {
+    super(message);
+    this.name = "FileLockedError";
+  }
+};
+async function withFileLock(lockPath, fn, options = {}) {
+  await mkdir(dirname(lockPath), { recursive: true, mode: 448 });
+  const deadline = Date.now() + (options.timeoutMs ?? DEFAULT_LOCK_TIMEOUT_MS);
+  const ownerRecord = {
+    pid: process.pid,
+    token: randomBytes2(16).toString("hex")
+  };
+  const owner = JSON.stringify(ownerRecord);
+  const releasedOwner = JSON.stringify({ ...ownerRecord, released: true });
+  let handle;
+  while (handle === void 0) {
+    await atomicFileTestHooks?.beforeLockAttempt?.(lockPath);
+    try {
+      const candidate = await open2(lockPath, "wx", 384);
+      try {
+        await candidate.writeFile(owner, "utf8");
+        await candidate.sync();
+        await atomicFileTestHooks?.afterLockCreate?.(lockPath);
+        if (await lockTakeoverInProgress(lockPath)) {
+          await candidate.close();
+          await removeOwnedLock(lockPath, [owner]);
+          await removeAbandonedLockTombs(lockPath);
+          if (Date.now() >= deadline) {
+            throw new FileLockedError(options.lockedMessage);
+          }
+          await new Promise((resolve) => setTimeout(resolve, LOCK_RETRY_MS));
+          continue;
+        }
+        handle = candidate;
+      } catch (error61) {
+        await candidate.close().catch(() => void 0);
+        await removeOwnedLock(lockPath, [owner]).catch(() => void 0);
+        throw error61;
+      }
+    } catch (error61) {
+      if (!hasCode(error61, "EEXIST")) throw error61;
+      await removeStaleLock(lockPath);
+      if (Date.now() >= deadline) {
+        throw new FileLockedError(options.lockedMessage);
+      }
+      await new Promise((resolve) => setTimeout(resolve, LOCK_RETRY_MS));
+    }
+  }
+  const ownedHandle = handle;
+  const heartbeat = setInterval(() => {
+    const time3 = /* @__PURE__ */ new Date();
+    void ownedHandle.utimes(time3, time3).catch(() => void 0);
+  }, LOCK_HEARTBEAT_MS);
+  heartbeat.unref();
+  try {
+    return await fn();
+  } finally {
+    clearInterval(heartbeat);
+    try {
+      await markLockReleased(ownedHandle, releasedOwner);
+    } finally {
+      try {
+        await ownedHandle.close();
+      } finally {
+        await removeOwnedLock(lockPath, [owner, releasedOwner]);
+      }
+    }
+  }
+}
+async function removeStaleLock(path) {
+  try {
+    const owner = await readFile(path, "utf8");
+    if (lockOwnerReleased(owner)) {
+      await removeOwnedLock(path, [owner]);
+      return;
+    }
+    const metadata = await stat(path);
+    if (Date.now() - metadata.mtimeMs <= LOCK_STALE_AFTER_MS) return;
+    const pid = lockOwnerPid(owner);
+    if (pid !== void 0 && processIsAlive(pid)) return;
+    await atomicFileTestHooks?.beforeStaleLockBreak?.(path);
+    await removeOwnedLock(path, [owner]);
+  } catch (error61) {
+    if (!hasCode(error61, "ENOENT")) throw error61;
+  }
+}
+async function removeOwnedLock(path, owners) {
+  const tombPath = `${path}.stale.${randomBytes2(16).toString("hex")}`;
+  try {
+    await rename(path, tombPath);
+  } catch (error61) {
+    if (hasCode(error61, "ENOENT")) {
+      await removeOwnedTombs(path, owners);
+      const currentOwner = await readFile(path, "utf8").catch(() => void 0);
+      if (currentOwner !== void 0 && owners.includes(currentOwner)) {
+        await removeOwnedLock(path, owners);
+      }
+      return;
+    }
+    throw error61;
+  }
+  let pendingError;
+  try {
+    const renamedOwner = await readFile(tombPath, "utf8");
+    if (!owners.includes(renamedOwner) && !lockOwnerReleased(renamedOwner)) {
+      await atomicFileTestHooks?.afterMismatchedLockRename?.(path);
+      const currentOwner = await readFile(tombPath, "utf8");
+      if (!lockOwnerReleased(currentOwner)) await restoreRenamedLock(path, tombPath);
+      await atomicFileTestHooks?.afterMismatchedLockRestore?.(path);
+    }
+  } catch (error61) {
+    pendingError = error61;
+  }
+  try {
+    await unlink(tombPath);
+  } catch (error61) {
+    if (!hasCode(error61, "ENOENT") && pendingError === void 0) {
+      pendingError = error61;
+    }
+  }
+  if (pendingError !== void 0) throw pendingError;
+}
+async function lockTakeoverInProgress(path) {
+  const prefix = `${basename(path)}.stale.`;
+  return (await readdir(dirname(path))).some((entry) => entry.startsWith(prefix));
+}
+async function removeAbandonedLockTombs(path) {
+  const directory = dirname(path);
+  const prefix = `${basename(path)}.stale.`;
+  for (const entry of await readdir(directory)) {
+    if (!entry.startsWith(prefix)) continue;
+    const tombPath = join2(directory, entry);
+    const [metadata, owner] = await Promise.all([
+      stat(tombPath).catch(() => void 0),
+      readFile(tombPath, "utf8").catch(() => void 0)
+    ]);
+    if (metadata === void 0 || owner === void 0) continue;
+    const pid = lockOwnerPid(owner);
+    const abandoned = lockOwnerReleased(owner) || Date.now() - metadata.mtimeMs > LOCK_STALE_AFTER_MS && (pid === void 0 || !processIsAlive(pid));
+    if (!abandoned) continue;
+    await unlink(tombPath).catch((error61) => {
+      if (!hasCode(error61, "ENOENT")) throw error61;
+    });
+  }
+}
+async function removeOwnedTombs(path, owners) {
+  const directory = dirname(path);
+  const prefix = `${basename(path)}.stale.`;
+  for (const entry of await readdir(directory)) {
+    if (!entry.startsWith(prefix)) continue;
+    const tombPath = join2(directory, entry);
+    const owner = await readFile(tombPath, "utf8").catch(() => void 0);
+    if (owner === void 0 || !owners.includes(owner)) continue;
+    await unlink(tombPath).catch((error61) => {
+      if (!hasCode(error61, "ENOENT")) throw error61;
+    });
+  }
+}
+async function restoreRenamedLock(path, tombPath) {
+  while (true) {
+    try {
+      await link(tombPath, path);
+      return;
+    } catch (error61) {
+      if (hasCode(error61, "ENOENT")) return;
+      if (!hasCode(error61, "EEXIST")) throw error61;
+      await new Promise((resolve) => setTimeout(resolve, LOCK_RETRY_MS));
+    }
+  }
+}
+async function markLockReleased(handle, owner) {
+  const contents = Buffer.from(owner, "utf8");
+  await handle.write(contents, 0, contents.length, 0);
+  await handle.truncate(contents.length);
+  await handle.sync();
+}
+function lockOwnerPid(owner) {
+  try {
+    const value = JSON.parse(owner);
+    if (typeof value !== "object" || value === null) return void 0;
+    const pid = Reflect.get(value, "pid");
+    return typeof pid === "number" && Number.isSafeInteger(pid) && pid > 0 ? pid : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function lockOwnerReleased(owner) {
+  try {
+    const value = JSON.parse(owner);
+    return typeof value === "object" && value !== null && Reflect.get(value, "released") === true;
+  } catch {
+    return false;
+  }
+}
+function processIsAlive(pid) {
+  if (atomicFileTestHooks?.isProcessAlive !== void 0) {
+    return atomicFileTestHooks.isProcessAlive(pid);
+  }
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error61) {
+    return hasCode(error61, "EPERM");
+  }
+}
+function hasCode(error61, code) {
+  return error61 instanceof Error && "code" in error61 && error61.code === code;
+}
+
 // src/x402-networks.ts
 var BASE_MAINNET_CAIP2 = "eip155:8453";
 var ARC_MAINNET_CAIP2 = "eip155:5042";
@@ -46592,6 +46811,205 @@ var BROWSER_ENABLED_X402_NETWORK_CONFIG = Object.freeze({
   [ARC_TESTNET_CAIP2]: browserNetwork(arcTestnetUsdc)
 });
 
+// src/net-guard.ts
+import { lookup as dnsLookup } from "node:dns/promises";
+import { request as httpRequest } from "node:http";
+import { request as httpsRequest } from "node:https";
+import { isIP } from "node:net";
+import { Readable } from "node:stream";
+var defaultLookup = async (hostname3) => {
+  const addresses = await dnsLookup(hostname3, { all: true });
+  return addresses.map(({ address }) => address);
+};
+async function assertPublicUrl(url2, options) {
+  if (url2.username || url2.password) {
+    throw guardError(url2);
+  }
+  if (url2.protocol !== "http:" && url2.protocol !== "https:") {
+    throw guardError(url2);
+  }
+  if (options.allowPrivateNetwork) {
+    return;
+  }
+  const hostname3 = normalizeHostname(url2.hostname);
+  const lowercaseHostname = hostname3.toLowerCase();
+  if (!lowercaseHostname || lowercaseHostname === "localhost" || lowercaseHostname.endsWith(".localhost") || lowercaseHostname.endsWith(".local") || lowercaseHostname.endsWith(".internal")) {
+    throw guardError(url2);
+  }
+  if (isIP(hostname3)) {
+    if (isNonPublicAddress(hostname3)) {
+      throw guardError(url2);
+    }
+    return;
+  }
+  let addresses;
+  try {
+    addresses = await withTimeout(
+      (options.lookup ?? defaultLookup)(hostname3),
+      options.timeoutMs ?? 5e3
+    );
+  } catch {
+    throw guardError(url2);
+  }
+  if (addresses.length === 0 || addresses.some(isNonPublicAddress)) {
+    throw guardError(url2);
+  }
+}
+function createPublicFetch(options) {
+  const lookupFn = options.lookup ?? defaultLookup;
+  return (async (input2, init) => {
+    const url2 = new URL(input2 instanceof Request ? input2.url : input2);
+    await assertPublicUrl(url2, {
+      allowPrivateNetwork: options.allowPrivateNetwork,
+      lookup: lookupFn,
+      timeoutMs: 5e3
+    });
+    const normalized = new Request(input2, init);
+    const bytes = normalized.body ? Buffer.from(await normalized.arrayBuffer()) : null;
+    return await new Promise((resolve, reject) => {
+      const requestOptions = {
+        method: normalized.method,
+        headers: Object.fromEntries(normalized.headers),
+        signal: normalized.signal,
+        ...options.allowPrivateNetwork ? {} : { lookup: pinnedLookup(lookupFn) }
+      };
+      const onResponse = (incoming) => {
+        try {
+          const headers = new Headers();
+          for (const [name, value] of Object.entries(incoming.headers)) {
+            if (Array.isArray(value)) {
+              for (const item of value) headers.append(name, item);
+            } else if (value !== void 0) {
+              headers.set(name, value);
+            }
+          }
+          const status = incoming.statusCode ?? 500;
+          const bodyForbidden = normalized.method === "HEAD" || [204, 205, 304].includes(status);
+          if (bodyForbidden) incoming.resume();
+          const response = new Response(
+            bodyForbidden ? null : Readable.toWeb(incoming),
+            { status, statusText: incoming.statusMessage, headers }
+          );
+          Object.defineProperty(response, "url", { value: url2.toString() });
+          resolve(response);
+        } catch (error61) {
+          incoming.destroy();
+          reject(error61);
+        }
+      };
+      const request = url2.protocol === "https:" ? httpsRequest(url2, requestOptions, onResponse) : httpRequest(url2, requestOptions, onResponse);
+      request.on("error", reject);
+      if (bytes) request.write(bytes);
+      request.end();
+    });
+  });
+}
+function pinnedLookup(lookup) {
+  return (hostname3, dnsOptions, callback) => {
+    void lookup(normalizeHostname(hostname3)).then((addresses) => {
+      if (addresses.length === 0 || addresses.some(isNonPublicAddress)) {
+        callback(guardError(new URL(`https://${hostname3}`)), "");
+        return;
+      }
+      const address = addresses[0];
+      const family = isIP(address);
+      callback(
+        null,
+        dnsOptions.all ? [{ address, family }] : address,
+        dnsOptions.all ? void 0 : family
+      );
+    }).catch(
+      (error61) => callback(error61 instanceof Error ? error61 : new Error("DNS lookup failed."), "")
+    );
+  };
+}
+async function withTimeout(operation, timeoutMs) {
+  let timeout;
+  try {
+    return await Promise.race([
+      operation,
+      new Promise((_resolve, reject) => {
+        timeout = setTimeout(() => reject(new Error("DNS lookup timed out.")), timeoutMs);
+      })
+    ]);
+  } finally {
+    if (timeout) clearTimeout(timeout);
+  }
+}
+function normalizeHostname(hostname3) {
+  const unbracketed = hostname3.startsWith("[") && hostname3.endsWith("]") ? hostname3.slice(1, -1) : hostname3;
+  return unbracketed.endsWith(".") ? unbracketed.slice(0, -1) : unbracketed;
+}
+function isNonPublicAddress(address) {
+  const normalized = normalizeHostname(address);
+  const version3 = isIP(normalized);
+  if (version3 === 4) {
+    return isNonPublicIpv4(parseIpv4(normalized));
+  }
+  if (version3 === 6) {
+    return isNonPublicIpv6(parseIpv6(normalized));
+  }
+  return true;
+}
+function parseIpv4(address) {
+  const octets = address.split(".").map(Number);
+  return [octets[0], octets[1], octets[2], octets[3]];
+}
+function isNonPublicIpv4([first, second, third]) {
+  return first === 0 || first === 10 || first === 100 && second >= 64 && second <= 127 || first === 127 || first === 169 && second === 254 || first === 172 && second >= 16 && second <= 31 || first === 192 && second === 0 && (third === 0 || third === 2) || first === 192 && second === 168 || first === 198 && second >= 18 && second <= 19 || first === 198 && second === 51 && third === 100 || first === 203 && second === 0 && third === 113 || first >= 224;
+}
+function parseIpv6(address) {
+  let normalized = address.toLowerCase();
+  const lastColon = normalized.lastIndexOf(":");
+  const dottedTail = normalized.slice(lastColon + 1);
+  if (dottedTail.includes(".")) {
+    const [first, second, third, fourth] = parseIpv4(dottedTail);
+    normalized = `${normalized.slice(0, lastColon + 1)}${(first << 8 | second).toString(16)}:${(third << 8 | fourth).toString(16)}`;
+  }
+  const halves = normalized.split("::");
+  const left = halves[0] ? halves[0].split(":").map(parseHex) : [];
+  const right = halves[1] ? halves[1].split(":").map(parseHex) : [];
+  const omittedCount = 8 - left.length - right.length;
+  return halves.length === 2 ? [...left, ...Array.from({ length: omittedCount }, () => 0), ...right] : left;
+}
+function parseHex(value) {
+  return Number.parseInt(value, 16);
+}
+function isNonPublicIpv6(hextets) {
+  if (hextets.slice(0, 5).every((hextet) => hextet === 0) && hextets[5] === 65535) {
+    const embeddedIpv4 = [
+      hextets[6] >> 8,
+      hextets[6] & 255,
+      hextets[7] >> 8,
+      hextets[7] & 255
+    ];
+    return isNonPublicIpv4(embeddedIpv4);
+  }
+  if (hextets.slice(0, 6).every((hextet) => hextet === 0)) {
+    const compatibleIpv4 = [
+      hextets[6] >> 8,
+      hextets[6] & 255,
+      hextets[7] >> 8,
+      hextets[7] & 255
+    ];
+    if (isNonPublicIpv4(compatibleIpv4)) return true;
+  }
+  const isUnspecified = hextets.every((hextet) => hextet === 0);
+  const isLoopback = hextets.slice(0, 7).every((hextet) => hextet === 0) && hextets[7] === 1;
+  const first = hextets[0];
+  const isUniqueLocal = first >= 64512 && first <= 65023;
+  const isLinkLocal = first >= 65152 && first <= 65215;
+  const isSiteLocal = first >= 65216 && first <= 65279;
+  const isMulticast = first >= 65280;
+  const isDocumentation = first === 8193 && hextets[1] === 3512;
+  return isUnspecified || isLoopback || isUniqueLocal || isLinkLocal || isSiteLocal || isMulticast || isDocumentation;
+}
+function guardError(url2) {
+  return new Error(
+    `URL hostname ${JSON.stringify(url2.hostname)} is not allowed; private or internal destinations require allowPrivateNetwork true in the vAPI config.`
+  );
+}
+
 // src/networks.ts
 var NETWORKS = {
   [BASE_MAINNET_CAIP2]: {
@@ -46667,6 +47085,10 @@ function isSupportedPaymentNetwork(network) {
 var DEFAULT_REGISTRY_URL = "https://api.vapinetwork.ai";
 var DEFAULT_DISCOVERY_URL = `${DEFAULT_REGISTRY_URL}/api/call/services`;
 var DEFAULT_MARKETPLACE_DISCOVERY_URL = `${DEFAULT_REGISTRY_URL}/api/call/discovery`;
+var DEFAULT_SPEND_CAPS = {
+  perCallAtomic: "100000",
+  perDayAtomic: "1000000"
+};
 var atomicString = external_exports.string().regex(/^\d+$/, "Expected non-negative atomic units.");
 var spendCapsSchema = external_exports.object({
   perCallAtomic: atomicString,
@@ -46729,22 +47151,22 @@ var configSchema = external_exports.object({
     }
   }
 });
-function getVapiPaths(directory = process.env.VAPI_HOME?.trim() || join2(homedir(), ".vapi")) {
+function getVapiPaths(directory = process.env.VAPI_HOME?.trim() || join3(homedir(), ".vapi")) {
   return {
     directory,
-    agentsDir: join2(directory, "agents"),
-    config: join2(directory, "config.json"),
-    keystore: join2(directory, "keystore.json"),
-    receipts: join2(directory, "receipts.jsonl"),
-    searches: join2(directory, "searches.jsonl"),
-    ledger: join2(directory, "spend-ledger.json")
+    agentsDir: join3(directory, "agents"),
+    config: join3(directory, "config.json"),
+    keystore: join3(directory, "keystore.json"),
+    receipts: join3(directory, "receipts.jsonl"),
+    searches: join3(directory, "searches.jsonl"),
+    ledger: join3(directory, "spend-ledger.json")
   };
 }
 async function migrateLegacyVapiHome(options = {}) {
   const target = getVapiPaths(options.targetDirectory);
-  const legacyDirectory = options.legacyDirectory ?? join2(homedir(), ".vapi", "agent-cash");
+  const legacyDirectory = options.legacyDirectory ?? join3(homedir(), ".vapi", "agent-cash");
   if (legacyDirectory === target.directory || !await pathExists(legacyDirectory)) return [];
-  await mkdir(target.directory, { recursive: true, mode: 448 });
+  await mkdir2(target.directory, { recursive: true, mode: 448 });
   const copied = [];
   for (const filename of [
     "config.json",
@@ -46753,10 +47175,17 @@ async function migrateLegacyVapiHome(options = {}) {
     "searches.jsonl",
     "spend-ledger.json"
   ]) {
-    const source = join2(legacyDirectory, filename);
-    const destination = join2(target.directory, filename);
+    const source = join3(legacyDirectory, filename);
+    const destination = join3(target.directory, filename);
     try {
-      await copyFile(source, destination, constants.COPYFILE_EXCL);
+      const copy = async () => await copyFile(source, destination, constants.COPYFILE_EXCL);
+      if (filename === "receipts.jsonl") {
+        await withFileLock(`${destination}.lock`, copy, {
+          lockedMessage: "The receipt journal is busy. Wait for the other vapi command to finish, then retry."
+        });
+      } else {
+        await copy();
+      }
       copied.push(destination);
     } catch (error61) {
       if (isMissingFile(error61) || isAlreadyExists(error61)) continue;
@@ -46772,7 +47201,7 @@ async function migrateLegacyVapiHome(options = {}) {
 }
 async function pathExists(path) {
   try {
-    await stat(path);
+    await stat2(path);
     return true;
   } catch (error61) {
     if (isMissingFile(error61)) return false;
@@ -46943,7 +47372,7 @@ function encryptWithKey(key, plaintext) {
   if (key.byteLength !== KEY_LENGTH) {
     throw new Error(`Expected a ${KEY_LENGTH}-byte AES-256-GCM key.`);
   }
-  const nonce = randomBytes2(12);
+  const nonce = randomBytes3(12);
   const cipher = createCipheriv("aes-256-gcm", key, nonce, {
     authTagLength: AUTH_TAG_LENGTH
   });
@@ -47027,7 +47456,7 @@ async function sealPlaintext(plaintext, passphrase) {
   if (passphrase.length === 0) {
     throw new KeystoreError("Keystore passphrase cannot be empty.");
   }
-  const salt = randomBytes2(32);
+  const salt = randomBytes3(32);
   const key = await deriveScryptKey(passphrase, salt);
   try {
     const sealed = encryptWithKey(key, Buffer.from(plaintext, "utf8"));
@@ -47145,7 +47574,7 @@ async function refuseExistingKeystore(path) {
     await migrateLegacyVapiHome({ targetDirectory: getVapiPaths().directory });
   }
   try {
-    await stat2(path);
+    await stat3(path);
     throw new KeystoreError(
       `Keystore already exists at ${path}. Refusing to replace the local payment key.`
     );
@@ -47167,7 +47596,7 @@ function validatePrivateKey(value) {
 async function readStoredKeystore(path) {
   let raw;
   try {
-    raw = await readFile2(path, "utf8");
+    raw = await readFile3(path, "utf8");
   } catch (error61) {
     if (isMissingFile(error61)) {
       throw new KeystoreError(`No vAPI keystore found at ${path}. Run vapi init.`);
@@ -47240,8 +47669,8 @@ async function createSolanaSigner(seed) {
   }
 }
 async function writeKeystore(path, keystore, exclusive) {
-  await mkdir2(dirname2(path), { recursive: true, mode: 448 });
-  const temporaryPath = `${path}.${process.pid}.${randomBytes2(6).toString("hex")}.tmp`;
+  await mkdir3(dirname3(path), { recursive: true, mode: 448 });
+  const temporaryPath = `${path}.${process.pid}.${randomBytes3(6).toString("hex")}.tmp`;
   await writeFile2(temporaryPath, `${JSON.stringify(keystore, null, 2)}
 `, {
     encoding: "utf8",
@@ -47250,7 +47679,7 @@ async function writeKeystore(path, keystore, exclusive) {
   });
   if (exclusive) {
     try {
-      await stat2(path);
+      await stat3(path);
       throw new KeystoreError(
         `Keystore already exists at ${path}. Refusing to replace the local payment key.`
       );
@@ -47258,13 +47687,13 @@ async function writeKeystore(path, keystore, exclusive) {
       if (!isMissingFile(error61)) throw error61;
     }
   }
-  await rename2(temporaryPath, path);
+  await rename3(temporaryPath, path);
 }
 
 // src/vault.ts
-import { randomBytes as randomBytes3 } from "node:crypto";
-import { mkdir as mkdir3, open as open2, readFile as readFile3, rename as rename3, rm, stat as stat3, unlink, writeFile as writeFile3 } from "node:fs/promises";
-import { dirname as dirname3 } from "node:path";
+import { randomBytes as randomBytes4 } from "node:crypto";
+import { mkdir as mkdir4, open as open3, readFile as readFile4, rename as rename4, rm, stat as stat4, unlink as unlink2, writeFile as writeFile3 } from "node:fs/promises";
+import { dirname as dirname4 } from "node:path";
 
 // src/wallet-name.ts
 var WALLET_NAME_PATTERN = /^[a-z0-9][a-z0-9-]{0,31}$/;
@@ -47272,6 +47701,9 @@ var walletNameSchema = external_exports.string().regex(
   WALLET_NAME_PATTERN,
   "A wallet name is 1 to 32 characters of lowercase letters, digits and dashes, starting with a letter or digit."
 );
+function isWalletName(value) {
+  return WALLET_NAME_PATTERN.test(value);
+}
 
 // src/vault.ts
 var VaultError = class extends Error {
@@ -47590,6 +48022,9 @@ async function exportVaultAccountKey(args) {
     throw asVaultError(error61, "corrupt", "Unable to export the vault account key.");
   }
 }
+async function exportMemberKey(args) {
+  return await exportVaultAccountKey(args);
+}
 function assertVaultKey(key) {
   if (key.byteLength !== 32) {
     throw new VaultError("bad_key", "A device vault key must contain exactly 32 bytes.");
@@ -47706,7 +48141,7 @@ async function readVaultFile(path, key) {
 async function readVaultFileUnlocked(path) {
   let raw;
   try {
-    raw = await readFile3(path, "utf8");
+    raw = await readFile4(path, "utf8");
   } catch (error61) {
     if (isMissingFile2(error61)) {
       throw new VaultError("not_found", "No vault file was found at the requested path.", {
@@ -47718,8 +48153,8 @@ async function readVaultFileUnlocked(path) {
   return parseVaultFile(raw);
 }
 async function writeVaultFile(path, file2) {
-  await mkdir3(dirname3(path), { recursive: true, mode: 448 });
-  const temporaryPath = `${path}.${process.pid}.${randomBytes3(6).toString("hex")}.tmp`;
+  await mkdir4(dirname4(path), { recursive: true, mode: 448 });
+  const temporaryPath = `${path}.${process.pid}.${randomBytes4(6).toString("hex")}.tmp`;
   try {
     await writeFile3(temporaryPath, `${JSON.stringify(file2, null, 2)}
 `, {
@@ -47727,20 +48162,20 @@ async function writeVaultFile(path, file2) {
       mode: 384,
       flag: "wx"
     });
-    await rename3(temporaryPath, path);
+    await rename4(temporaryPath, path);
   } catch (error61) {
     await rm(temporaryPath, { force: true }).catch(() => void 0);
     throw error61;
   }
 }
 async function withVaultLock(path, operation) {
-  await mkdir3(dirname3(path), { recursive: true, mode: 448 });
+  await mkdir4(dirname4(path), { recursive: true, mode: 448 });
   const lockPath = `${path}.lock`;
   const deadline = Date.now() + VAULT_LOCK_TIMEOUT_MS;
   let handle;
   while (!handle) {
     try {
-      handle = await open2(lockPath, "wx", 384);
+      handle = await open3(lockPath, "wx", 384);
     } catch (error61) {
       if (!isExistingFile(error61)) throw error61;
       await removeStaleVaultLock(lockPath);
@@ -47754,13 +48189,13 @@ async function withVaultLock(path, operation) {
     return await operation();
   } finally {
     await handle.close();
-    await unlink(lockPath).catch(() => void 0);
+    await unlink2(lockPath).catch(() => void 0);
   }
 }
 async function removeStaleVaultLock(path) {
   try {
-    const metadata = await stat3(path);
-    if (Date.now() - metadata.mtimeMs > STALE_VAULT_LOCK_MS) await unlink(path);
+    const metadata = await stat4(path);
+    if (Date.now() - metadata.mtimeMs > STALE_VAULT_LOCK_MS) await unlink2(path);
   } catch (error61) {
     if (!isMissingFile2(error61)) throw error61;
   }
@@ -47774,12 +48209,413 @@ function isExistingFile(error61) {
 function asVaultError(error61, code, message) {
   return error61 instanceof VaultError ? error61 : new VaultError(code, message, { cause: error61 });
 }
+
+// src/device.ts
+var DEVICE_NAME_PATTERN = /^[a-z0-9][a-z0-9-]{0,31}$/;
+
+// src/agent-link.ts
+var DEFAULT_AGENT_SCOPES = ["mcp:call", "router.use"];
+var ALLOWED_AGENT_SCOPES = /* @__PURE__ */ new Set([...DEFAULT_AGENT_SCOPES, "call.publish"]);
+var publicFetch = createPublicFetch({ allowPrivateNetwork: false });
+var agentSecretAccounts = (wallet) => ({
+  tokens: `vapi.agent.${wallet}.tokens`,
+  routerStake: `vapi.agent.${wallet}.router.stake`,
+  routerBalance: `vapi.agent.${wallet}.router.balance`
+});
+
+// src/agent-profile.ts
+var DEFAULT_AGENT_TOOLS = ["call.search", "call.inspect", "call.pay"];
+var AGENT_GRANTS = ["read", "delegate", "allocate"];
+var agentProfileShape = {
+  version: external_exports.literal(1),
+  name: walletNameSchema,
+  wallet: external_exports.string(),
+  model: external_exports.string().min(1),
+  instructions: external_exports.string().max(2e4),
+  verifiedOnly: external_exports.boolean().default(true),
+  approveAboveUsd: external_exports.number().min(0).default(0.5),
+  maxSteps: external_exports.number().int().min(1).max(50).default(12),
+  paused: external_exports.boolean().default(false),
+  grants: external_exports.array(external_exports.enum(AGENT_GRANTS)).default([]),
+  createdAt: external_exports.string()
+};
+function createAgentProfileSchema(toolNames) {
+  if (toolNames.length === 0) {
+    throw new Error("Agent profiles require at least one registered tool.");
+  }
+  const tools = [...toolNames];
+  return external_exports.object({ ...agentProfileShape, tools: external_exports.array(external_exports.enum(tools)).default(tools) });
+}
+var agentProfileSchema = createAgentProfileSchema(DEFAULT_AGENT_TOOLS);
+
+// src/agent-run.ts
+var RUN_ID_PATTERN = /^run_[0-9a-f]{24}$/;
+var runRefSchema = external_exports.strictObject({
+  id: external_exports.string().regex(RUN_ID_PATTERN),
+  swarm: external_exports.string().optional(),
+  member: external_exports.string().optional(),
+  parentRunId: external_exports.string().optional()
+});
+
+// src/swarm.ts
+var SWARM_NAME_PATTERN = /^[a-z][a-z0-9-]{0,15}$/;
+var SWARM_ROLE_PATTERN = /^[a-z][a-z0-9]{0,7}$/;
+var atomicSchema = external_exports.string().regex(/^\d+$/);
+var addressSchema2 = external_exports.string().regex(/^0x[0-9a-fA-F]{40}$/);
+var capsSchema = external_exports.strictObject({ perCallAtomic: atomicSchema, perDayAtomic: atomicSchema });
+var movementIdSchema = external_exports.string().regex(/^mv_[A-Za-z0-9_-]{8,128}$/u);
+var amountUsdSchema = external_exports.string().regex(/^\d+\.\d{2}$/u);
+var setupFundingStatusSchema = external_exports.enum(["planned", "sent", "incomplete"]);
+var blockedFundingLegSchema = external_exports.strictObject({
+  to: external_exports.string().trim().min(1),
+  amountUsd: amountUsdSchema,
+  reason: external_exports.string().trim().min(1)
+});
+var setupFundingSchema = external_exports.strictObject({
+  amountUsd: amountUsdSchema,
+  from: walletNameSchema,
+  movementId: movementIdSchema.optional(),
+  status: setupFundingStatusSchema,
+  policy: external_exports.strictObject({
+    strategy: external_exports.enum(["targets", "even", "weights"]),
+    movementId: movementIdSchema.optional(),
+    status: setupFundingStatusSchema,
+    blocked: external_exports.array(blockedFundingLegSchema).optional()
+  }).optional()
+});
+var accountSteps = {
+  creating: external_exports.boolean().default(false),
+  created: external_exports.boolean(),
+  capped: external_exports.boolean(),
+  linked: external_exports.boolean()
+};
+var treasurySchema = external_exports.strictObject({
+  account: walletNameSchema,
+  // A planned account has no address until its vault derivation succeeds.
+  address: addressSchema2.optional(),
+  steps: external_exports.strictObject(accountSteps)
+}).refine(
+  (value) => !value.steps.created || value.address !== void 0,
+  "Created accounts require an address."
+);
+var memberSchema = external_exports.strictObject({
+  account: walletNameSchema,
+  address: addressSchema2.optional(),
+  role: external_exports.string().regex(SWARM_ROLE_PATTERN),
+  weight: external_exports.number().int().positive(),
+  targetAtomic: atomicSchema,
+  ceilingAtomic: atomicSchema.nullable(),
+  steps: external_exports.strictObject({ ...accountSteps, profiled: external_exports.boolean() })
+}).refine(
+  (value) => !value.steps.created || value.address !== void 0,
+  "Created accounts require an address."
+);
+var swarmFileSchema = external_exports.strictObject({
+  v: external_exports.literal(1),
+  name: external_exports.string().regex(SWARM_NAME_PATTERN),
+  device: external_exports.string().regex(DEVICE_NAME_PATTERN),
+  network: external_exports.enum([BASE_MAINNET_CAIP2, ARC_MAINNET_CAIP2]),
+  createdAt: external_exports.iso.datetime(),
+  treasury: treasurySchema,
+  members: external_exports.array(memberSchema),
+  setupFunding: setupFundingSchema.optional(),
+  policy: external_exports.strictObject({
+    strategy: external_exports.enum(["targets", "even", "weights"]),
+    treasuryCaps: capsSchema
+  })
+}).refine(
+  (value) => (/* @__PURE__ */ new Set([value.treasury.account, ...value.members.map((member) => member.account)])).size === value.members.length + 1,
+  "Swarm accounts must be unique."
+);
+
+// src/member-bundle.ts
+var MEMBER_BUNDLE_MAX_BYTES = 32 * 1024;
+var REMOTE_BLOCKED_GRANTS = /* @__PURE__ */ new Set([
+  "delegate",
+  "allocate"
+]);
+var BASE64URL_PATTERN = /^[A-Za-z0-9_-]+$/;
+var ADDRESS_PATTERN2 = /^0x[0-9a-fA-F]{40}$/;
+var PRIVATE_KEY_PATTERN = /^0x[0-9a-fA-F]{64}$/;
+var ATOMIC_PATTERN = /^\d+$/;
+var FORBIDDEN_CONFIG_KEYS = /* @__PURE__ */ new Set(["rpcUrl", "apiKey"]);
+var MemberBundleError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "MemberBundleError";
+  }
+  code;
+};
+var hexString = (pattern, message) => external_exports.custom((value) => typeof value === "string" && pattern.test(value), message);
+var linkSchema = external_exports.strictObject({
+  apiBase: external_exports.string(),
+  clientId: external_exports.string(),
+  owner: external_exports.custom((value) => typeof value === "string" && value.startsWith("0x")),
+  label: external_exports.string(),
+  scopes: external_exports.array(external_exports.string()),
+  linkedAt: external_exports.iso.datetime(),
+  routerBaseUrl: external_exports.string().optional()
+});
+var remoteTokensSchema = external_exports.strictObject({
+  accessToken: external_exports.string().min(1),
+  expiresAt: external_exports.number().finite(),
+  scopes: external_exports.array(external_exports.string()),
+  refreshable: external_exports.literal(false)
+});
+var storedTokensSchema = external_exports.object({
+  accessToken: external_exports.string().min(1),
+  refreshToken: external_exports.string().min(1),
+  expiresAt: external_exports.number().finite(),
+  scopes: external_exports.array(external_exports.string())
+});
+var credentialsSchema = external_exports.strictObject({
+  tokens: external_exports.string().min(1).refine(isRemoteTokens, "A member bundle carries a non-refreshable access token only."),
+  routerStake: external_exports.string().min(1).optional(),
+  routerBalance: external_exports.string().min(1).optional()
+});
+var remoteProfileSchema = agentProfileSchema.strict().refine((profile) => profile.grants.every((grant) => !REMOTE_BLOCKED_GRANTS.has(grant)), {
+  message: "A remote member never holds the delegate or allocate grant.",
+  path: ["grants"]
+});
+var credentialFreeUrl = external_exports.url().refine((value) => unsafeUrlPart(value) === void 0, {
+  message: "A member bundle URL never carries a user name, password, query or fragment."
+});
+var memberBundleConfigSchema = external_exports.unknown().refine((value) => !hasForbiddenConfigKey(value), {
+  message: "A member bundle never carries RPC URLs or API keys."
+}).pipe(
+  external_exports.strictObject({
+    discoveryUrl: credentialFreeUrl,
+    marketplaceDiscoveryUrl: credentialFreeUrl,
+    networks: external_exports.record(
+      external_exports.string().refine(isMemberBundleNetwork, {
+        message: "Expected a network with a public RPC default."
+      }),
+      external_exports.strictObject({ usdc: external_exports.string() })
+    ).refine(
+      (networks) => Object.entries(networks).every(
+        ([id, network]) => isMemberBundleNetwork(id) && network.usdc === NETWORKS[id].usdc
+      ),
+      { message: "Expected the canonical USDC token of each network." }
+    ).refine((networks) => Object.keys(networks).length === 1, {
+      message: "A member bundle carries exactly one network: the swarm's."
+    })
+  })
+);
+var memberBundleSchema = external_exports.strictObject({
+  v: external_exports.literal(1),
+  account: walletNameSchema,
+  address: hexString(ADDRESS_PATTERN2, "Expected a 20-byte 0x address."),
+  privateKey: hexString(PRIVATE_KEY_PATTERN, "Expected a 32-byte 0x private key."),
+  swarm: external_exports.string().regex(SWARM_NAME_PATTERN),
+  profile: remoteProfileSchema,
+  link: linkSchema,
+  credentials: credentialsSchema,
+  caps: external_exports.strictObject(spendCapsSchema.shape),
+  allowanceExpiresAt: external_exports.iso.datetime(),
+  ceilingAtomic: external_exports.string().regex(ATOMIC_PATTERN, "Expected non-negative atomic units."),
+  config: memberBundleConfigSchema,
+  runId: external_exports.string().regex(RUN_ID_PATTERN),
+  parentRunId: external_exports.string().regex(RUN_ID_PATTERN).optional()
+});
+function memberBundleConfig(owner, network) {
+  const discoveryUrl = safeDiscoveryUrl("discoveryUrl", owner.discoveryUrl);
+  const marketplaceDiscoveryUrl = safeDiscoveryUrl(
+    "marketplaceDiscoveryUrl",
+    owner.marketplaceDiscoveryUrl
+  );
+  if (!Object.hasOwn(owner.networks, network) || !isMemberBundleNetwork(network)) {
+    throw new MemberBundleError(
+      "unsupported_network",
+      `A member bundle runs on the swarm network ${network}, which must be enabled in this config and have a public RPC default.`
+    );
+  }
+  return {
+    discoveryUrl,
+    marketplaceDiscoveryUrl,
+    networks: { [network]: { usdc: NETWORKS[network].usdc } }
+  };
+}
+function headlessConfigFromBundle(config2) {
+  const networks = {};
+  for (const [id, network] of Object.entries(config2.networks)) {
+    if (!isMemberBundleNetwork(id) || network === void 0) continue;
+    networks[id] = { rpcUrl: NETWORKS[id].publicRpcUrl, usdc: network.usdc };
+  }
+  return configSchema.parse({
+    discoveryUrl: config2.discoveryUrl,
+    marketplaceDiscoveryUrl: config2.marketplaceDiscoveryUrl,
+    networks,
+    spendCaps: { ...DEFAULT_SPEND_CAPS }
+  });
+}
+function createMemberBundle(input2) {
+  const bundle = parseBundle({ ...input2, profile: withoutRemoteGrants(input2.profile), v: 1 });
+  assertKeyMatchesAddress(bundle);
+  const encoded = Buffer.from(JSON.stringify(bundle), "utf8").toString("base64url");
+  if (encoded.length > MEMBER_BUNDLE_MAX_BYTES) {
+    throw new MemberBundleError(
+      "too_large",
+      `The member bundle is larger than ${MEMBER_BUNDLE_MAX_BYTES} bytes.`
+    );
+  }
+  return encoded;
+}
+function openMemberBundle(text) {
+  if (typeof text !== "string") {
+    throw new MemberBundleError("invalid", "The member bundle is not a string.");
+  }
+  if (text.length > MEMBER_BUNDLE_MAX_BYTES) {
+    throw new MemberBundleError(
+      "too_large",
+      `The member bundle is larger than ${MEMBER_BUNDLE_MAX_BYTES} bytes.`
+    );
+  }
+  if (!BASE64URL_PATTERN.test(text)) {
+    throw new MemberBundleError("invalid", "The member bundle is not base64url text.");
+  }
+  let decoded;
+  try {
+    decoded = JSON.parse(Buffer.from(text, "base64url").toString("utf8"));
+  } catch {
+    throw new MemberBundleError("invalid", "The member bundle does not decode to JSON.");
+  }
+  const bundle = parseBundle(decoded);
+  assertKeyMatchesAddress(bundle);
+  return bundle;
+}
+async function readMemberCredentials(args) {
+  if (!isWalletName(args.account)) {
+    throw new MemberBundleError("invalid", "The member account name is not valid.");
+  }
+  const names = agentSecretAccounts(args.account);
+  const storedTokens = await args.secrets.get(names.tokens);
+  if (storedTokens === void 0 || storedTokens === "") {
+    throw new MemberBundleError(
+      "not_linked",
+      `The account ${args.account} is not linked to vAPI. Link it with vapi login first.`
+    );
+  }
+  const routerStake = await args.secrets.get(names.routerStake);
+  const routerBalance = await args.secrets.get(names.routerBalance);
+  const parsed = parseStoredTokens(storedTokens);
+  if (parsed === void 0) {
+    throw new MemberBundleError(
+      "not_linked",
+      `The account ${args.account}'s vAPI credentials cannot be exported safely. Run vapi login --account ${args.account} again.`
+    );
+  }
+  const tokens = JSON.stringify({
+    accessToken: parsed.accessToken,
+    expiresAt: parsed.expiresAt,
+    scopes: parsed.scopes,
+    refreshable: false
+  });
+  return {
+    tokens,
+    ...routerStake === void 0 || routerStake === "" ? {} : { routerStake },
+    ...routerBalance === void 0 || routerBalance === "" ? {} : { routerBalance }
+  };
+}
+function isRemoteTokens(value) {
+  try {
+    return remoteTokensSchema.safeParse(JSON.parse(value)).success;
+  } catch {
+    return false;
+  }
+}
+function parseStoredTokens(value) {
+  try {
+    const parsed = storedTokensSchema.safeParse(JSON.parse(value));
+    return parsed.success ? parsed.data : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function isMemberBundleNetwork(id) {
+  return Object.hasOwn(NETWORKS, id) && typeof NETWORKS[id].publicRpcUrl === "string";
+}
+function hasForbiddenConfigKey(value) {
+  if (Array.isArray(value)) return value.some(hasForbiddenConfigKey);
+  if (typeof value !== "object" || value === null) return false;
+  return Object.entries(value).some(
+    ([key, item]) => FORBIDDEN_CONFIG_KEYS.has(key) || hasForbiddenConfigKey(item)
+  );
+}
+function unsafeUrlPart(value) {
+  let url2;
+  try {
+    url2 = new URL(value);
+  } catch {
+    return "an unparseable value";
+  }
+  if (url2.username !== "" || url2.password !== "") return "a user name or password";
+  if (url2.search !== "" || value.includes("?")) return "a query string";
+  if (url2.hash !== "" || value.includes("#")) return "a fragment";
+  return void 0;
+}
+function safeDiscoveryUrl(field, value) {
+  const part = unsafeUrlPart(value);
+  if (part !== void 0) {
+    throw new MemberBundleError(
+      "unsafe_config",
+      `The owner config's ${field} has ${part}, which can carry a credential, so it never goes into a member bundle. Point ${field} at a plain URL (check VAPI_DISCOVERY_URL, VAPI_MARKETPLACE_DISCOVERY_URL and config.json).`
+    );
+  }
+  return value;
+}
+function withoutRemoteGrants(profile) {
+  if (typeof profile !== "object" || profile === null || !Array.isArray(profile.grants)) {
+    return profile;
+  }
+  return {
+    ...profile,
+    grants: profile.grants.filter((grant) => !REMOTE_BLOCKED_GRANTS.has(grant))
+  };
+}
+function parseBundle(value) {
+  const parsed = memberBundleSchema.safeParse(value);
+  if (!parsed.success) {
+    const fields = [
+      ...new Set(parsed.error.issues.map((issue2) => issue2.path.map(String).join(".") || "(root)"))
+    ];
+    throw new MemberBundleError(
+      "invalid",
+      `The member bundle is not valid (fields: ${fields.join(", ")}).`
+    );
+  }
+  return parsed.data;
+}
+function assertKeyMatchesAddress(bundle) {
+  let derived;
+  try {
+    derived = privateKeyToAccount(bundle.privateKey).address;
+  } catch {
+    throw new MemberBundleError("key_mismatch", "The member bundle's key is not a valid key.");
+  }
+  if (derived.toLowerCase() !== bundle.address.toLowerCase()) {
+    throw new MemberBundleError(
+      "key_mismatch",
+      "The member bundle's key does not match its address."
+    );
+  }
+}
 export {
+  MEMBER_BUNDLE_MAX_BYTES,
+  MemberBundleError,
   createKeystoreWithPhrase,
+  createMemberBundle,
   decryptPrivateKey,
   exportKeystoreKeys,
+  exportMemberKey,
   exportRecoveryPhrase,
   exportVaultAccountKey,
-  exportVaultPhrase
+  exportVaultPhrase,
+  headlessConfigFromBundle,
+  memberBundleConfig,
+  memberBundleConfigSchema,
+  memberBundleSchema,
+  openMemberBundle,
+  readMemberCredentials
 };
 //# sourceMappingURL=secrets.js.map