@vellumai/assistant 0.10.2-dev.202606250318.5e7cfb0 → 0.10.2

package/src/runtime/__tests__/trust-verdict-consumer.test.ts

@@ -2,7 +2,6 @@ import { describe, expect, test } from "bun:test";
 
 import type { TrustVerdict } from "@vellumai/gateway-client";
 
-import { channelStatusToMemberStatus } from "../../contacts/member-status.js";
 import type {
   ContactChannel,
   ContactWithChannels,
@@ -10,12 +9,8 @@ import type {
 import type { ActorTrustContext } from "../actor-trust-resolver.js";
 import { toTrustContext } from "../actor-trust-resolver.js";
 import {
-  actorTrustContextFromVerdict,
   resolvedMemberFromVerdict,
   trustContextFromVerdict,
-  verdictHasMemberIdentity,
-  verdictMemberFromVerdict,
-  verdictMemberUnresolvable,
 } from "../trust-verdict-consumer.js";
 
 const CONV = "conv-123";
@@ -168,195 +163,6 @@ describe("trustContextFromVerdict", () => {
   });
 });
 
-describe("actorTrustContextFromVerdict", () => {
-  test("maps guardian verdict fields", () => {
-    const verdict = {
-      trustClass: "guardian",
-      canonicalSenderId: "+15550100",
-      guardianExternalUserId: "+15550100",
-      guardianDeliveryChatId: "chat-9",
-      guardianPrincipalId: "vellum-principal-abc",
-      memberDisplayName: "Alice",
-    } satisfies TrustVerdict;
-
-    const ctx = actorTrustContextFromVerdict(verdict, {
-      sourceChannel: "phone",
-      conversationExternalId: CONV,
-      actorUsername: "alice",
-      actorDisplayName: "Alice Sender",
-    });
-
-    expect(ctx).toEqual({
-      canonicalSenderId: "+15550100",
-      guardianBindingMatch: {
-        guardianExternalUserId: "+15550100",
-        guardianDeliveryChatId: "chat-9",
-      },
-      guardianPrincipalId: "vellum-principal-abc",
-      memberRecord: null,
-      trustClass: "guardian",
-      actorMetadata: {
-        identifier: "@alice",
-        displayName: "Alice",
-        senderDisplayName: "Alice Sender",
-        memberDisplayName: "Alice",
-        username: "alice",
-        channel: "phone",
-        trustStatus: "guardian",
-      },
-    });
-  });
-
-  test("guardianBindingMatch is null without guardianExternalUserId", () => {
-    const verdict = {
-      trustClass: "trusted_contact",
-      canonicalSenderId: "+15550101",
-      memberDisplayName: "Bob",
-    } satisfies TrustVerdict;
-
-    const ctx = actorTrustContextFromVerdict(verdict, {
-      sourceChannel: "phone",
-      conversationExternalId: CONV,
-    });
-
-    expect(ctx.guardianBindingMatch).toBeNull();
-    expect(ctx.trustClass).toBe("trusted_contact");
-    // identifier falls back to canonicalSenderId when no username.
-    expect(ctx.actorMetadata.identifier).toBe("+15550101");
-    // displayName uses memberDisplayName when present.
-    expect(ctx.actorMetadata.displayName).toBe("Bob");
-    expect(ctx.actorMetadata.channel).toBe("phone");
-    expect(ctx.memberRecord).toBeNull();
-  });
-
-  test("displayName falls back to actorDisplayName; identifier uses @username", () => {
-    const verdict = {
-      trustClass: "unverified_contact",
-      canonicalSenderId: "u-1",
-    } satisfies TrustVerdict;
-
-    const ctx = actorTrustContextFromVerdict(verdict, {
-      sourceChannel: "slack",
-      conversationExternalId: CONV,
-      actorUsername: "carol",
-      actorDisplayName: "Carol Display",
-    });
-
-    expect(ctx.trustClass).toBe("unverified_contact");
-    expect(ctx.actorMetadata.identifier).toBe("@carol");
-    expect(ctx.actorMetadata.displayName).toBe("Carol Display");
-    expect(ctx.actorMetadata.memberDisplayName).toBeUndefined();
-    expect(ctx.actorMetadata.trustStatus).toBe("unverified_contact");
-  });
-
-  test("maps unknown verdict with no identity overrides", () => {
-    const verdict = {
-      trustClass: "unknown",
-      canonicalSenderId: "u-2",
-    } satisfies TrustVerdict;
-
-    const ctx = actorTrustContextFromVerdict(verdict, {
-      sourceChannel: "slack",
-      conversationExternalId: CONV,
-    });
-
-    expect(ctx.trustClass).toBe("unknown");
-    expect(ctx.guardianBindingMatch).toBeNull();
-    expect(ctx.guardianPrincipalId).toBeUndefined();
-    expect(ctx.memberRecord).toBeNull();
-    expect(ctx.actorMetadata.identifier).toBe("u-2");
-    expect(ctx.actorMetadata.displayName).toBeUndefined();
-  });
-
-  test("member verdict populates memberRecord from the verdict (voice ACL)", () => {
-    const verdict = {
-      trustClass: "trusted_contact",
-      canonicalSenderId: "u-1",
-      contactId: "contact-1",
-      channelId: "channel-1",
-      type: "slack",
-      address: "u-1",
-      status: "blocked",
-      policy: "deny",
-    } satisfies TrustVerdict;
-
-    const ctx = actorTrustContextFromVerdict(verdict, {
-      sourceChannel: "slack",
-      conversationExternalId: CONV,
-    });
-
-    expect(ctx.memberRecord).not.toBeNull();
-    expect(ctx.memberRecord!.contact.id).toBe("contact-1");
-    expect(ctx.memberRecord!.channel.id).toBe("channel-1");
-    expect(ctx.memberRecord!.channel.status).toBe("blocked");
-    expect(ctx.memberRecord!.channel.policy).toBe("deny");
-  });
-
-  test("stranger verdict (no contactId/channelId) leaves memberRecord null", () => {
-    const verdict = {
-      trustClass: "unknown",
-      canonicalSenderId: "u-9",
-    } satisfies TrustVerdict;
-
-    const ctx = actorTrustContextFromVerdict(verdict, {
-      sourceChannel: "slack",
-      conversationExternalId: CONV,
-    });
-
-    expect(ctx.memberRecord).toBeNull();
-  });
-
-  test("malformed member verdict (unknown status) leaves memberRecord null (fail-closed)", () => {
-    const verdict = {
-      trustClass: "trusted_contact",
-      canonicalSenderId: "u-10",
-      contactId: "contact-10",
-      channelId: "channel-10",
-      status: "quarantined",
-      policy: "allow",
-    } satisfies TrustVerdict;
-
-    const ctx = actorTrustContextFromVerdict(verdict, {
-      sourceChannel: "slack",
-      conversationExternalId: CONV,
-    });
-
-    expect(ctx.memberRecord).toBeNull();
-  });
-
-  test("trustContextFromVerdict equals member stamp applied to toTrustContext(actorTrustContextFromVerdict)", () => {
-    const verdict = {
-      trustClass: "trusted_contact",
-      canonicalSenderId: "u-1",
-      contactId: "contact-1",
-      channelId: "channel-1",
-      type: "slack",
-      address: "u-1",
-      status: "unverified",
-      policy: "escalate",
-      memberDisplayName: "Dora",
-    } satisfies TrustVerdict;
-    const input = {
-      sourceChannel: "slack",
-      conversationExternalId: CONV,
-      actorUsername: "dora",
-      actorDisplayName: "Dora Display",
-    } as const;
-
-    const expected = toTrustContext(
-      actorTrustContextFromVerdict(verdict, input),
-      input.conversationExternalId,
-    );
-    const member = resolvedMemberFromVerdict(verdict);
-    expect(member).not.toBeNull();
-    expected.requesterContactId = member!.contact.id;
-    expected.memberStatus = channelStatusToMemberStatus(member!.channel.status);
-    expected.memberPolicy = member!.channel.policy;
-
-    expect(trustContextFromVerdict(verdict, input)).toEqual(expected);
-  });
-});
-
 describe("toTrustContext member grounding", () => {
   function memberChannel(
     overrides: Partial<ContactChannel> = {},
@@ -401,7 +207,9 @@ describe("toTrustContext member grounding", () => {
     };
   }
 
-  function ctxWithMember(channel: ContactChannel): ActorTrustContext {
+  function ctxWithMember(
+    channel: ContactChannel,
+  ): ActorTrustContext {
     return {
       canonicalSenderId: "+15550100",
       guardianBindingMatch: null,
@@ -607,143 +415,3 @@ describe("resolvedMemberFromVerdict", () => {
     }
   });
 });
-
-describe("verdictMemberFromVerdict", () => {
-  test("active member verdict yields the narrow ACL view", () => {
-    const verdict = {
-      trustClass: "trusted_contact",
-      canonicalSenderId: "u-1",
-      contactId: "contact-1",
-      channelId: "channel-1",
-      type: "slack",
-      address: "u-1",
-      status: "active",
-      policy: "allow",
-      verifiedAt: 1700000000,
-      memberDisplayName: "Dora",
-    } satisfies TrustVerdict;
-
-    expect(verdictMemberFromVerdict(verdict)).toEqual({
-      contactId: "contact-1",
-      channelId: "channel-1",
-      status: "active",
-      policy: "allow",
-      verifiedAt: 1700000000,
-      displayName: "Dora",
-    });
-  });
-
-  test("blocked member verdict surfaces status/policy verbatim, null defaults", () => {
-    const verdict = {
-      trustClass: "unknown",
-      canonicalSenderId: "u-3",
-      contactId: "contact-3",
-      channelId: "channel-3",
-      status: "blocked",
-      policy: "deny",
-    } satisfies TrustVerdict;
-
-    expect(verdictMemberFromVerdict(verdict)).toEqual({
-      contactId: "contact-3",
-      channelId: "channel-3",
-      status: "blocked",
-      policy: "deny",
-      verifiedAt: null,
-      displayName: null,
-    });
-  });
-
-  test("memberless verdict (no contactId/channelId) returns null", () => {
-    expect(
-      verdictMemberFromVerdict({
-        trustClass: "unknown",
-        canonicalSenderId: "u-2",
-      } satisfies TrustVerdict),
-    ).toBeNull();
-  });
-
-  test("invalid enum (unknown status/policy) returns null (fail-closed)", () => {
-    expect(
-      verdictMemberFromVerdict({
-        trustClass: "trusted_contact",
-        canonicalSenderId: "u-7",
-        contactId: "contact-7",
-        channelId: "channel-7",
-        status: "quarantined",
-        policy: "allow",
-      } satisfies TrustVerdict),
-    ).toBeNull();
-    expect(
-      verdictMemberFromVerdict({
-        trustClass: "trusted_contact",
-        canonicalSenderId: "u-6",
-        contactId: "contact-6",
-        channelId: "channel-6",
-        status: "active",
-        policy: "bogus",
-      } satisfies TrustVerdict),
-    ).toBeNull();
-  });
-});
-
-describe("verdict predicates", () => {
-  test("verdictHasMemberIdentity is true with contactId or channelId", () => {
-    expect(
-      verdictHasMemberIdentity({
-        trustClass: "unknown",
-        canonicalSenderId: "u-1",
-        contactId: "contact-1",
-      } satisfies TrustVerdict),
-    ).toBe(true);
-    expect(
-      verdictHasMemberIdentity({
-        trustClass: "unknown",
-        canonicalSenderId: "u-1",
-        channelId: "channel-1",
-      } satisfies TrustVerdict),
-    ).toBe(true);
-  });
-
-  test("verdictHasMemberIdentity is false for a memberless verdict", () => {
-    expect(
-      verdictHasMemberIdentity({
-        trustClass: "unknown",
-        canonicalSenderId: "u-1",
-      } satisfies TrustVerdict),
-    ).toBe(false);
-  });
-
-  test("verdictMemberUnresolvable is true when member identity present but ACL unsynthesizable", () => {
-    expect(
-      verdictMemberUnresolvable({
-        trustClass: "trusted_contact",
-        canonicalSenderId: "u-1",
-        contactId: "contact-1",
-        channelId: "channel-1",
-        policy: "allow",
-      } satisfies TrustVerdict),
-    ).toBe(true);
-  });
-
-  test("verdictMemberUnresolvable is false for a usable member verdict", () => {
-    expect(
-      verdictMemberUnresolvable({
-        trustClass: "trusted_contact",
-        canonicalSenderId: "u-1",
-        contactId: "contact-1",
-        channelId: "channel-1",
-        status: "active",
-        policy: "allow",
-      } satisfies TrustVerdict),
-    ).toBe(false);
-  });
-
-  test("verdictMemberUnresolvable is false for a memberless verdict", () => {
-    expect(
-      verdictMemberUnresolvable({
-        trustClass: "unknown",
-        canonicalSenderId: "u-1",
-      } satisfies TrustVerdict),
-    ).toBe(false);
-  });
-});

package/src/runtime/access-request-helper.ts

@@ -12,7 +12,7 @@
  */
 
 import type { ChannelId } from "../channels/types.js";
-import { getGuardianDelivery } from "../contacts/guardian-delivery-reader.js";
+import { findGuardianForChannel } from "../contacts/contact-store.js";
 import type { ChannelStatus } from "../contacts/types.js";
 import {
   createCanonicalGuardianRequest,
@@ -25,7 +25,6 @@ import {
 import { emitNotificationSignal } from "../notifications/emit-signal.js";
 import type { GuardianResolutionSource } from "../notifications/signal.js";
 import { getLogger } from "../util/logger.js";
-import { resolveAnchoredGuardian } from "./anchored-guardian.js";
 import { GUARDIAN_APPROVAL_TTL_MS } from "./routes/channel-route-shared.js";
 
 const log = getLogger("access-request-helper");
@@ -71,12 +70,12 @@ export type AccessRequestResult =
  * trust anchor and only accepts source-channel contacts that match it. This
  * prevents stale or cross-assistant contacts from being bound to the request.
  *
- * The canonical store writes complete before this resolves; the notification
- * signal emission is fire-and-forget.
+ * This is intentionally synchronous with respect to the canonical store writes
+ * and fire-and-forget for the notification signal emission.
  */
-export async function notifyGuardianOfAccessRequest(
+export function notifyGuardianOfAccessRequest(
   params: AccessRequestParams,
-): Promise<AccessRequestResult> {
+): AccessRequestResult {
   const {
     canonicalAssistantId,
     sourceChannel,
@@ -95,19 +94,40 @@ export async function notifyGuardianOfAccessRequest(
     return { notified: false, reason: "no_sender_id" };
   }
 
-  // Resolve guardian identity with the assistant-anchored strategy (gateway
-  // source-channel match validated against the vellum anchor, else the vellum
-  // anchor), with a LOCAL-store fallback when the gateway read is empty.
-  const anchored = resolveAnchoredGuardian({
-    guardians: await getGuardianDelivery(),
-    sourceChannel,
-    useLocalFallback: true,
-  });
-  const guardianExternalUserId = anchored?.address ?? null;
-  const guardianPrincipalId = anchored?.principalId ?? null;
-  const guardianBindingChannel = anchored?.channelType ?? null;
-  const guardianResolutionSource: GuardianResolutionSource =
-    anchored?.source ?? "none";
+  // Resolve guardian identity with assistant-anchored strategy:
+  // 1. Ensure the assistant has a vellum guardian principal (trust anchor)
+  // 2. Use source-channel guardian only when principal matches anchor
+  // 3. Fallback to vellum guardian identity for this assistant principal
+  let guardianExternalUserId: string | null = null;
+  let guardianPrincipalId: string | null = null;
+  let guardianBindingChannel: string | null = null;
+  let guardianResolutionSource: GuardianResolutionSource = "none";
+
+  const vellumGuardian = findGuardianForChannel("vellum");
+  const assistantGuardianPrincipalId = vellumGuardian?.contact.principalId;
+
+  // Try source-channel guardian, but only if it maps to the assistant's
+  // anchored principal. This blocks cross-assistant/stale contact selection.
+  const sourceGuardian = findGuardianForChannel(sourceChannel);
+  if (
+    assistantGuardianPrincipalId &&
+    sourceGuardian &&
+    sourceGuardian.contact.principalId === assistantGuardianPrincipalId
+  ) {
+    guardianExternalUserId = sourceGuardian.channel.address;
+    guardianPrincipalId = sourceGuardian.contact.principalId;
+    guardianBindingChannel = sourceGuardian.channel.type;
+    guardianResolutionSource = "source-channel-contact";
+  }
+
+  // Access requests always require a principal. If source-channel resolution
+  // did not match the assistant anchor, use the anchored vellum identity.
+  if (!guardianPrincipalId && vellumGuardian) {
+    guardianExternalUserId = vellumGuardian.channel.address;
+    guardianPrincipalId = assistantGuardianPrincipalId ?? null;
+    guardianBindingChannel = guardianBindingChannel ?? "vellum";
+    guardianResolutionSource = "vellum-anchor";
+  }
 
   log.debug(
     {

package/src/runtime/actor-trust-resolver.ts

@@ -323,8 +323,8 @@ export function toTrustContext(
     requesterMemberDisplayName: ctx.actorMetadata.memberDisplayName,
     requesterExternalUserId: ctx.canonicalSenderId ?? undefined,
     requesterChatId: conversationExternalId,
-    // Member grounding from the resolved memberRecord (voice + verdict paths
-    // both populate it).
+    // Member grounding from a real memberRecord (voice path); the verdict path
+    // (memberRecord=null) stamps these from the verdict instead.
     requesterContactId: ctx.memberRecord?.contact.id,
     memberStatus: ctx.memberRecord
       ? channelStatusToMemberStatus(ctx.memberRecord.channel.status)

package/src/runtime/assistant-event-hub.ts

@@ -749,7 +749,7 @@ async function createCanonicalRequestForConfirmation(
     });
 
     if (trustContext && conversation) {
-      await bridgeConfirmationRequestToGuardian({
+      bridgeConfirmationRequestToGuardian({
         canonicalRequest,
         trustContext,
         conversationId,

package/src/runtime/assistant-stream-state.ts

@@ -50,21 +50,14 @@
 import { mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 
-import {
-  SSE_REPLAY_RING_AGE_LIMIT_MS,
-  SSE_REPLAY_RING_COUNT_LIMIT,
-} from "../api/constants/sse-replay.js";
 import { getWorkspaceDir } from "../util/platform.js";
 import type { AssistantEvent } from "./assistant-event.js";
 
 // ── Tunables ─────────────────────────────────────────────────────────
 
-// Count and age bounds on the replay ring. Shared with the web client
-// (via `@vellumai/assistant-api`) so its seq-gap tolerance is sized
-// against the same numbers the daemon buffers against.
-const RING_COUNT_LIMIT = SSE_REPLAY_RING_COUNT_LIMIT;
+const RING_COUNT_LIMIT = 200;
 const RING_SIZE_LIMIT_BYTES = 256 * 1024;
-const RING_AGE_LIMIT_MS = SSE_REPLAY_RING_AGE_LIMIT_MS;
+const RING_AGE_LIMIT_MS = 30_000;
 
 /**
  * Cap on how many conversations retain a persisted-seq entry. Unlike the

package/src/runtime/auth/require-bound-guardian.ts

@@ -1,20 +1,15 @@
 import { isHttpAuthDisabled } from "../../config/env.js";
-import {
-  getGuardianDelivery,
-  guardianForChannel,
-} from "../../contacts/guardian-delivery-reader.js";
+import { findGuardianForChannel } from "../../contacts/contact-store.js";
 import { httpError } from "../http-errors.js";
 import type { AuthContext } from "./types.js";
 
 /**
  * Verify the actor from AuthContext is the bound guardian for the vellum channel.
- * Sources the guardian from the gateway binding and fails closed when the
- * gateway is unreachable (null list). Returns an error Response if not
- * authorized, or null if allowed.
+ * Returns an error Response if not, or null if allowed.
  */
-export async function requireBoundGuardian(
+export function requireBoundGuardian(
   authContext: AuthContext,
-): Promise<Response | null> {
+): Response | null {
   // Dev bypass: when auth is disabled, skip guardian binding check
   // (mirrors enforcePolicy dev bypass in route-policy.ts)
   if (isHttpAuthDisabled()) {
@@ -27,22 +22,17 @@ export async function requireBoundGuardian(
       403,
     );
   }
-  const guardians = await getGuardianDelivery({ channelTypes: ["vellum"] });
-  if (!guardians) {
-    // Gateway unreachable — fail closed.
+  const guardianResult = findGuardianForChannel("vellum");
+  if (!guardianResult) {
+    // No guardian yet — in pre-bootstrap state, allow through
+    return null;
+  }
+  if (guardianResult.channel.address !== authContext.actorPrincipalId) {
     return httpError(
       "FORBIDDEN",
       "Actor is not the bound guardian for this channel",
       403,
     );
   }
-  const guardian = guardianForChannel(guardians, "vellum");
-  if (guardian && guardian.principalId === authContext.actorPrincipalId) {
-    return null;
-  }
-  return httpError(
-    "FORBIDDEN",
-    "Actor is not the bound guardian for this channel",
-    403,
-  );
+  return null;
 }

package/src/runtime/channel-verification-service.ts

@@ -9,12 +9,8 @@
 import { createHash, randomBytes } from "crypto";
 import { v4 as uuid } from "uuid";
 
+import { findGuardianForChannel } from "../contacts/contact-store.js";
 import { revokeGuardianBinding } from "../contacts/contacts-write.js";
-import {
-  getGuardianDelivery,
-  getGuardianDeliveryFresh,
-  guardianForChannel,
-} from "../contacts/guardian-delivery-reader.js";
 import type {
   GuardianBinding,
   IdentityBindingStatus,
@@ -323,71 +319,50 @@ export function validateAndConsumeVerification(
 
 /**
  * Look up the active guardian binding for a given assistant and channel.
- * Reads the gateway-owned GuardianDelivery and synthesizes a
- * GuardianBinding-shaped object. Returns null when no guardian is bound or
- * the gateway is unreachable.
+ * Reads from the contacts table via findGuardianForChannel and
+ * synthesizes a GuardianBinding-shaped object.
+ * Returns null when no contacts match.
  */
-export async function getGuardianBinding(
+export function getGuardianBinding(
   assistantId: string,
   channel: string,
-): Promise<GuardianBinding | null> {
-  const list = await getGuardianDelivery({ channelTypes: [channel] });
-  const delivery = list ? guardianForChannel(list, channel) : undefined;
-  if (!delivery) return null;
-
-  const now = Date.now();
-  return {
-    id: delivery.contactId,
-    assistantId,
-    channel,
-    guardianExternalUserId: delivery.address,
-    guardianDeliveryChatId: delivery.externalChatId ?? "",
-    guardianPrincipalId: delivery.principalId ?? "",
-    status: "active" as const,
-    verifiedAt: delivery.verifiedAt ?? 0,
-    // verifiedVia is not carried on the delivery contract; a bound guardian
-    // is verified by definition.
-    verifiedVia: "verified",
-    metadataJson: null,
-    createdAt: now,
-    updatedAt: now,
-  };
-}
+): GuardianBinding | null {
+  const result = findGuardianForChannel(channel);
+  if (result) {
+    return {
+      id: result.channel.id,
+      assistantId,
+      channel,
+      guardianExternalUserId: result.channel.address,
+      guardianDeliveryChatId: result.channel.externalChatId ?? "",
+      guardianPrincipalId: result.contact.principalId ?? "",
+      status: "active" as const,
+      verifiedAt: result.channel.verifiedAt ?? 0,
+      verifiedVia: result.channel.verifiedVia ?? "",
+      metadataJson: null,
+      createdAt: result.channel.createdAt,
+      updatedAt: result.channel.updatedAt ?? result.channel.createdAt,
+    };
+  }
 
-/**
- * Gateway-backed guardian-existence check: is a guardian already bound for
- * this channel? Presence-only idempotency guard, NOT an ACL-field read.
- *
- * Null-list fail direction: a `null` from the gateway (unreachable / malformed)
- * is "unknown" — returns `true` so an unreachable gateway is treated as
- * already-bound. Callers gate session creation on a falsy result, so this
- * blocks a new binding on a transient miss rather than spuriously creating a
- * second one.
- */
-export async function isGuardianBoundForChannel(
-  channel: string,
-): Promise<boolean> {
-  // Existence guards read fresh because gateway-side binding writes don't
-  // invalidate the daemon cache.
-  const list = await getGuardianDeliveryFresh({ channelTypes: [channel] });
-  if (list === null) return true;
-  return !!guardianForChannel(list, channel);
+  return null;
 }
 
 /**
  * Check whether the given external user is the active guardian for
  * the specified assistant and channel.
  */
-export async function isGuardian(
+export function isGuardian(
   assistantId: string,
   channel: string,
   address: string,
-): Promise<boolean> {
-  const list = await getGuardianDelivery({ channelTypes: [channel] });
-  const delivery = list ? guardianForChannel(list, channel) : undefined;
-  if (!delivery) return false;
+): boolean {
+  const result = findGuardianForChannel(channel);
+  if (result) {
+    return result.channel.address.toLowerCase() === address.toLowerCase();
+  }
 
-  return delivery.address.toLowerCase() === address.toLowerCase();
+  return false;
 }
 
 /**