holosphere 2.0.0-alpha1 → 2.0.0-alpha11

package/tests/unit/integration/scenario-12-capability-federated-read.test.js

@@ -1,719 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import HoloSphere from '../../../src/index.js';
-
-/**
- * Scenario 12: Capability-Based Federated Data Access
- *
- * This test verifies that:
- * 1. Capability tokens work correctly for read, write, and delete operations
- * 2. The federation registry correctly stores and retrieves capabilities
- * 3. Capability verification works for different permission levels
- * 4. Scope matching works correctly (holon, lens, dataId levels)
- *
- * Note: In test environment with MemoryStorage, we use different appNames
- * to simulate isolation between holospheres. In production with Nostr relays,
- * isolation is enforced by author (public key) filtering.
- */
-describe('Integration: Scenario 12 - Capability-Based Federated Read', () => {
-  // Three distinct private keys for three separate holospheres
-  const privateKeyA = '0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef';
-  const privateKeyB = 'fedcba9876543210fedcba9876543210fedcba9876543210fedcba9876543210';
-  const privateKeyC = 'abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789';
-
-  let holosphereA;
-  let holosphereB;
-  let holosphereC;
-  let publicKeyA;
-  let publicKeyB;
-  let publicKeyC;
-  let testHolon;
-  let testHolon2;
-
-  beforeEach(async () => {
-    // Create three independent holospheres with different appNames for isolation
-    // In production with Nostr, they would use same appName but different keys
-    holosphereA = new HoloSphere({
-      relays: [],
-      appName: 'scenario-12-a',
-      privateKey: privateKeyA,
-      logLevel: 'ERROR'
-    });
-
-    holosphereB = new HoloSphere({
-      relays: [],
-      appName: 'scenario-12-b',
-      privateKey: privateKeyB,
-      logLevel: 'ERROR'
-    });
-
-    holosphereC = new HoloSphere({
-      relays: [],
-      appName: 'scenario-12-c',
-      privateKey: privateKeyC,
-      logLevel: 'ERROR'
-    });
-
-    // Get public keys
-    publicKeyA = holosphereA.client.publicKey;
-    publicKeyB = holosphereB.client.publicKey;
-    publicKeyC = holosphereC.client.publicKey;
-
-    // Create test holons (H3 cells)
-    testHolon = await holosphereA.toHolon(37.7749, -122.4194, 9);
-    testHolon2 = await holosphereA.toHolon(40.7128, -74.0060, 9);
-  });
-
-  afterEach(async () => {
-    // Clean up
-    if (holosphereA?.client?.close) await holosphereA.client.close();
-    if (holosphereB?.client?.close) await holosphereB.client.close();
-    if (holosphereC?.client?.close) await holosphereC.client.close();
-  });
-
-  describe('Capability Token Permissions', () => {
-    it('should issue and verify capability token with READ permission', async () => {
-      const token = await holosphereA.issueCapability(
-        ['read'],
-        { holonId: testHolon, lensName: 'documents' },
-        publicKeyB,
-        { expiresIn: 3600000, issuerKey: privateKeyA }
-      );
-
-      expect(typeof token).toBe('string');
-
-      // Verify read permission is granted
-      const hasRead = await holosphereB.verifyCapability(token, 'read', {
-        holonId: testHolon,
-        lensName: 'documents'
-      });
-      expect(hasRead).toBe(true);
-
-      // Verify write permission is NOT granted
-      const hasWrite = await holosphereB.verifyCapability(token, 'write', {
-        holonId: testHolon,
-        lensName: 'documents'
-      });
-      expect(hasWrite).toBe(false);
-
-      // Verify delete permission is NOT granted
-      const hasDelete = await holosphereB.verifyCapability(token, 'delete', {
-        holonId: testHolon,
-        lensName: 'documents'
-      });
-      expect(hasDelete).toBe(false);
-    });
-
-    it('should issue and verify capability token with WRITE permission', async () => {
-      const token = await holosphereA.issueCapability(
-        ['write'],
-        { holonId: testHolon, lensName: 'documents' },
-        publicKeyB,
-        { expiresIn: 3600000, issuerKey: privateKeyA }
-      );
-
-      const hasWrite = await holosphereB.verifyCapability(token, 'write', {
-        holonId: testHolon,
-        lensName: 'documents'
-      });
-      expect(hasWrite).toBe(true);
-
-      const hasRead = await holosphereB.verifyCapability(token, 'read', {
-        holonId: testHolon,
-        lensName: 'documents'
-      });
-      expect(hasRead).toBe(false);
-    });
-
-    it('should issue and verify capability token with DELETE permission', async () => {
-      const token = await holosphereA.issueCapability(
-        ['delete'],
-        { holonId: testHolon, lensName: 'documents' },
-        publicKeyB,
-        { expiresIn: 3600000, issuerKey: privateKeyA }
-      );
-
-      const hasDelete = await holosphereB.verifyCapability(token, 'delete', {
-        holonId: testHolon,
-        lensName: 'documents'
-      });
-      expect(hasDelete).toBe(true);
-
-      const hasWrite = await holosphereB.verifyCapability(token, 'write', {
-        holonId: testHolon,
-        lensName: 'documents'
-      });
-      expect(hasWrite).toBe(false);
-    });
-
-    it('should issue capability token with ALL permissions (read, write, delete)', async () => {
-      const token = await holosphereA.issueCapability(
-        ['read', 'write', 'delete'],
-        { holonId: testHolon, lensName: 'documents' },
-        publicKeyB,
-        { expiresIn: 3600000, issuerKey: privateKeyA }
-      );
-
-      const hasRead = await holosphereB.verifyCapability(token, 'read', {
-        holonId: testHolon,
-        lensName: 'documents'
-      });
-      expect(hasRead).toBe(true);
-
-      const hasWrite = await holosphereB.verifyCapability(token, 'write', {
-        holonId: testHolon,
-        lensName: 'documents'
-      });
-      expect(hasWrite).toBe(true);
-
-      const hasDelete = await holosphereB.verifyCapability(token, 'delete', {
-        holonId: testHolon,
-        lensName: 'documents'
-      });
-      expect(hasDelete).toBe(true);
-    });
-
-    it('should reject expired capability tokens', async () => {
-      const expiredToken = await holosphereA.issueCapability(
-        ['read', 'write', 'delete'],
-        { holonId: testHolon, lensName: 'documents' },
-        publicKeyB,
-        { expiresIn: -1000, issuerKey: privateKeyA } // Already expired
-      );
-
-      const hasRead = await holosphereB.verifyCapability(expiredToken, 'read', {
-        holonId: testHolon,
-        lensName: 'documents'
-      });
-      expect(hasRead).toBe(false);
-
-      const hasWrite = await holosphereB.verifyCapability(expiredToken, 'write', {
-        holonId: testHolon,
-        lensName: 'documents'
-      });
-      expect(hasWrite).toBe(false);
-    });
-  });
-
-  describe('Write Operations with Capability Tokens', () => {
-    it('should allow write operation with valid write capability token', async () => {
-      // A issues write capability to B
-      const writeToken = await holosphereA.issueCapability(
-        ['write'],
-        { holonId: testHolon, lensName: 'shared' },
-        publicKeyB,
-        { expiresIn: 3600000, issuerKey: privateKeyA }
-      );
-
-      // B writes data using the capability token
-      await holosphereB.write(testHolon, 'shared', {
-        id: 'item-from-b',
-        content: 'Written by B with capability',
-        author: publicKeyB
-      }, { capability: writeToken });
-
-      // B can read their own data
-      const data = await holosphereB.read(testHolon, 'shared', 'item-from-b');
-      expect(data).toBeDefined();
-      expect(data.content).toBe('Written by B with capability');
-    });
-
-    it('should reject write with invalid capability token', async () => {
-      // Create an invalid token (for wrong scope)
-      const wrongScopeToken = await holosphereA.issueCapability(
-        ['write'],
-        { holonId: testHolon, lensName: 'other-lens' },
-        publicKeyB,
-        { expiresIn: 3600000, issuerKey: privateKeyA }
-      );
-
-      // Verify token is invalid for 'shared' lens
-      const isValid = await holosphereB.verifyCapability(wrongScopeToken, 'write', {
-        holonId: testHolon,
-        lensName: 'shared'
-      });
-      expect(isValid).toBe(false);
-    });
-
-    it('should reject write with read-only capability token', async () => {
-      const readOnlyToken = await holosphereA.issueCapability(
-        ['read'],
-        { holonId: testHolon, lensName: 'protected' },
-        publicKeyB,
-        { expiresIn: 3600000, issuerKey: privateKeyA }
-      );
-
-      // Verify token doesn't have write permission
-      const hasWrite = await holosphereB.verifyCapability(readOnlyToken, 'write', {
-        holonId: testHolon,
-        lensName: 'protected'
-      });
-      expect(hasWrite).toBe(false);
-    });
-  });
-
-  describe('Delete Operations with Capability Tokens', () => {
-    it('should allow delete operation with valid delete capability token', async () => {
-      // A writes data
-      await holosphereA.write(testHolon, 'deletable', {
-        id: 'to-delete',
-        content: 'This will be deleted'
-      });
-
-      // Verify data exists
-      const exists = await holosphereA.read(testHolon, 'deletable', 'to-delete');
-      expect(exists).toBeDefined();
-
-      // A issues delete capability to B
-      const deleteToken = await holosphereA.issueCapability(
-        ['delete'],
-        { holonId: testHolon, lensName: 'deletable' },
-        publicKeyB,
-        { expiresIn: 3600000, issuerKey: privateKeyA }
-      );
-
-      // Verify B has delete permission
-      const hasDelete = await holosphereB.verifyCapability(deleteToken, 'delete', {
-        holonId: testHolon,
-        lensName: 'deletable'
-      });
-      expect(hasDelete).toBe(true);
-    });
-
-    it('should reject delete with write-only capability token', async () => {
-      const writeOnlyToken = await holosphereA.issueCapability(
-        ['write'],
-        { holonId: testHolon, lensName: 'no-delete' },
-        publicKeyB,
-        { expiresIn: 3600000, issuerKey: privateKeyA }
-      );
-
-      // Verify token doesn't have delete permission
-      const hasDelete = await holosphereB.verifyCapability(writeOnlyToken, 'delete', {
-        holonId: testHolon,
-        lensName: 'no-delete'
-      });
-      expect(hasDelete).toBe(false);
-    });
-  });
-
-  describe('Federation Registry Operations', () => {
-    it('should store and retrieve inbound capability', async () => {
-      // A issues capability to B
-      const readToken = await holosphereA.issueCapability(
-        ['read'],
-        { holonId: testHolon, lensName: 'federated-docs' },
-        publicKeyB,
-        { expiresIn: 3600000, issuerKey: privateKeyA }
-      );
-
-      // B stores the capability
-      await holosphereB.storeInboundCapability(publicKeyA, {
-        token: readToken,
-        scope: { holonId: testHolon, lensName: 'federated-docs' },
-        permissions: ['read'],
-        expires: Date.now() + 3600000
-      });
-
-      // B can verify the stored capability
-      const isValid = await holosphereB.verifyCapability(readToken, 'read', {
-        holonId: testHolon,
-        lensName: 'federated-docs'
-      });
-      expect(isValid).toBe(true);
-    });
-
-    it('should store capabilities from multiple partners', async () => {
-      // A issues capability to C
-      const tokenFromA = await holosphereA.issueCapability(
-        ['read'],
-        { holonId: testHolon, lensName: 'multi-partner' },
-        publicKeyC,
-        { expiresIn: 3600000, issuerKey: privateKeyA }
-      );
-
-      // B issues capability to C
-      const tokenFromB = await holosphereB.issueCapability(
-        ['read', 'write'],
-        { holonId: testHolon, lensName: 'multi-partner' },
-        publicKeyC,
-        { expiresIn: 3600000, issuerKey: privateKeyB }
-      );
-
-      // C stores both capabilities
-      await holosphereC.storeInboundCapability(publicKeyA, {
-        token: tokenFromA,
-        scope: { holonId: testHolon, lensName: 'multi-partner' },
-        permissions: ['read'],
-        expires: Date.now() + 3600000
-      });
-
-      await holosphereC.storeInboundCapability(publicKeyB, {
-        token: tokenFromB,
-        scope: { holonId: testHolon, lensName: 'multi-partner' },
-        permissions: ['read', 'write'],
-        expires: Date.now() + 3600000
-      });
-
-      // C can verify both capabilities
-      const validFromA = await holosphereC.verifyCapability(tokenFromA, 'read', {
-        holonId: testHolon,
-        lensName: 'multi-partner'
-      });
-      expect(validFromA).toBe(true);
-
-      const validFromB = await holosphereC.verifyCapability(tokenFromB, 'write', {
-        holonId: testHolon,
-        lensName: 'multi-partner'
-      });
-      expect(validFromB).toBe(true);
-    });
-  });
-
-  describe('Scope Matching for Capabilities', () => {
-    it('should validate capability only for correct holon scope', async () => {
-      // Token for testHolon only
-      const token = await holosphereA.issueCapability(
-        ['read'],
-        { holonId: testHolon, lensName: 'scoped' },
-        publicKeyB,
-        { expiresIn: 3600000, issuerKey: privateKeyA }
-      );
-
-      // Valid for testHolon
-      const validForHolon1 = await holosphereB.verifyCapability(token, 'read', {
-        holonId: testHolon,
-        lensName: 'scoped'
-      });
-      expect(validForHolon1).toBe(true);
-
-      // Invalid for testHolon2
-      const validForHolon2 = await holosphereB.verifyCapability(token, 'read', {
-        holonId: testHolon2,
-        lensName: 'scoped'
-      });
-      expect(validForHolon2).toBe(false);
-    });
-
-    it('should validate capability only for correct lens scope', async () => {
-      // Token for lens-a only
-      const token = await holosphereA.issueCapability(
-        ['read'],
-        { holonId: testHolon, lensName: 'lens-a' },
-        publicKeyB,
-        { expiresIn: 3600000, issuerKey: privateKeyA }
-      );
-
-      // Valid for lens-a
-      const validForLensA = await holosphereB.verifyCapability(token, 'read', {
-        holonId: testHolon,
-        lensName: 'lens-a'
-      });
-      expect(validForLensA).toBe(true);
-
-      // Invalid for lens-b
-      const validForLensB = await holosphereB.verifyCapability(token, 'read', {
-        holonId: testHolon,
-        lensName: 'lens-b'
-      });
-      expect(validForLensB).toBe(false);
-    });
-
-    it('should support wildcard holon scope (*)', async () => {
-      // Token with wildcard holon
-      const wildcardToken = await holosphereA.issueCapability(
-        ['read'],
-        { holonId: '*', lensName: 'global' },
-        publicKeyB,
-        { expiresIn: 3600000, issuerKey: privateKeyA }
-      );
-
-      // Valid for any holon
-      const validForHolon1 = await holosphereB.verifyCapability(wildcardToken, 'read', {
-        holonId: testHolon,
-        lensName: 'global'
-      });
-      expect(validForHolon1).toBe(true);
-
-      const validForHolon2 = await holosphereB.verifyCapability(wildcardToken, 'read', {
-        holonId: testHolon2,
-        lensName: 'global'
-      });
-      expect(validForHolon2).toBe(true);
-
-      // But still restricted to 'global' lens
-      const invalidForOtherLens = await holosphereB.verifyCapability(wildcardToken, 'read', {
-        holonId: testHolon,
-        lensName: 'other-lens'
-      });
-      expect(invalidForOtherLens).toBe(false);
-    });
-
-    it('should support wildcard lens scope (*)', async () => {
-      // Token with wildcard lens
-      const wildcardToken = await holosphereA.issueCapability(
-        ['read'],
-        { holonId: testHolon, lensName: '*' },
-        publicKeyB,
-        { expiresIn: 3600000, issuerKey: privateKeyA }
-      );
-
-      // Valid for any lens in testHolon
-      const validForLensA = await holosphereB.verifyCapability(wildcardToken, 'read', {
-        holonId: testHolon,
-        lensName: 'lens-a'
-      });
-      expect(validForLensA).toBe(true);
-
-      const validForLensB = await holosphereB.verifyCapability(wildcardToken, 'read', {
-        holonId: testHolon,
-        lensName: 'lens-b'
-      });
-      expect(validForLensB).toBe(true);
-
-      // But still restricted to testHolon
-      const invalidForOtherHolon = await holosphereB.verifyCapability(wildcardToken, 'read', {
-        holonId: testHolon2,
-        lensName: 'lens-a'
-      });
-      expect(invalidForOtherHolon).toBe(false);
-    });
-
-    it('should support full wildcard scope (*, *)', async () => {
-      // Token with full wildcard - access to all holons and lenses
-      const fullWildcardToken = await holosphereA.issueCapability(
-        ['read'],
-        { holonId: '*', lensName: '*' },
-        publicKeyB,
-        { expiresIn: 3600000, issuerKey: privateKeyA }
-      );
-
-      // Valid for any holon and lens combination
-      const valid1 = await holosphereB.verifyCapability(fullWildcardToken, 'read', {
-        holonId: testHolon,
-        lensName: 'lens-a'
-      });
-      expect(valid1).toBe(true);
-
-      const valid2 = await holosphereB.verifyCapability(fullWildcardToken, 'read', {
-        holonId: testHolon2,
-        lensName: 'lens-b'
-      });
-      expect(valid2).toBe(true);
-    });
-
-    it('should support dataId-specific scope', async () => {
-      // Token for specific item only
-      const itemToken = await holosphereA.issueCapability(
-        ['read'],
-        { holonId: testHolon, lensName: 'items', dataId: 'item-2' },
-        publicKeyB,
-        { expiresIn: 3600000, issuerKey: privateKeyA }
-      );
-
-      // Valid for item-2
-      const validForItem2 = await holosphereB.verifyCapability(itemToken, 'read', {
-        holonId: testHolon,
-        lensName: 'items',
-        dataId: 'item-2'
-      });
-      expect(validForItem2).toBe(true);
-
-      // Invalid for item-1
-      const validForItem1 = await holosphereB.verifyCapability(itemToken, 'read', {
-        holonId: testHolon,
-        lensName: 'items',
-        dataId: 'item-1'
-      });
-      expect(validForItem1).toBe(false);
-    });
-  });
-
-  describe('Complete Capability Workflow', () => {
-    it('should complete full capability workflow: issue -> verify -> use', async () => {
-      // === STEP 1: A issues full capability (read, write, delete) to B ===
-      const fullCapability = await holosphereA.issueCapability(
-        ['read', 'write', 'delete'],
-        { holonId: testHolon, lensName: 'workflow-test' },
-        publicKeyB,
-        { expiresIn: 3600000, issuerKey: privateKeyA }
-      );
-
-      expect(typeof fullCapability).toBe('string');
-
-      // === STEP 2: B stores the capability ===
-      await holosphereB.storeInboundCapability(publicKeyA, {
-        token: fullCapability,
-        scope: { holonId: testHolon, lensName: 'workflow-test' },
-        permissions: ['read', 'write', 'delete'],
-        expires: Date.now() + 3600000
-      });
-
-      // === STEP 3: B verifies all permissions ===
-      const hasRead = await holosphereB.verifyCapability(fullCapability, 'read', {
-        holonId: testHolon,
-        lensName: 'workflow-test'
-      });
-      expect(hasRead).toBe(true);
-
-      const hasWrite = await holosphereB.verifyCapability(fullCapability, 'write', {
-        holonId: testHolon,
-        lensName: 'workflow-test'
-      });
-      expect(hasWrite).toBe(true);
-
-      const hasDelete = await holosphereB.verifyCapability(fullCapability, 'delete', {
-        holonId: testHolon,
-        lensName: 'workflow-test'
-      });
-      expect(hasDelete).toBe(true);
-
-      // === STEP 4: B can write data with capability ===
-      await holosphereB.write(testHolon, 'workflow-test', {
-        id: 'b-contribution',
-        title: 'B Contribution',
-        content: 'Added by B with capability',
-        contributor: publicKeyB
-      }, { capability: fullCapability });
-
-      // Verify write worked
-      const bContrib = await holosphereB.read(testHolon, 'workflow-test', 'b-contribution');
-      expect(bContrib).toBeDefined();
-      expect(bContrib.title).toBe('B Contribution');
-
-      // === STEP 5: B deletes with capability ===
-      const deleteResult = await holosphereB.delete(testHolon, 'workflow-test', 'b-contribution', {
-        capability: fullCapability
-      });
-      expect(deleteResult).toBe(true);
-
-      // Verify deletion
-      const deleted = await holosphereB.read(testHolon, 'workflow-test', 'b-contribution');
-      expect(deleted).toBeNull();
-    });
-
-    it('should properly isolate data between holospheres (different appNames)', async () => {
-      // A writes data
-      await holosphereA.write(testHolon, 'isolated', {
-        id: 'a-data',
-        content: 'From A',
-        owner: publicKeyA
-      });
-
-      // B writes data
-      await holosphereB.write(testHolon, 'isolated', {
-        id: 'b-data',
-        content: 'From B',
-        owner: publicKeyB
-      });
-
-      // A can only see A's data
-      const aData = await holosphereA.read(testHolon, 'isolated', 'a-data');
-      expect(aData).toBeDefined();
-      expect(aData.content).toBe('From A');
-
-      const aSeesB = await holosphereA.read(testHolon, 'isolated', 'b-data');
-      expect(aSeesB).toBeNull(); // Different appName
-
-      // B can only see B's data
-      const bData = await holosphereB.read(testHolon, 'isolated', 'b-data');
-      expect(bData).toBeDefined();
-      expect(bData.content).toBe('From B');
-
-      const bSeesA = await holosphereB.read(testHolon, 'isolated', 'a-data');
-      expect(bSeesA).toBeNull(); // Different appName
-    });
-  });
-
-  describe('Capability Token Security', () => {
-    it('should not allow capability reuse for different scope', async () => {
-      const token = await holosphereA.issueCapability(
-        ['read', 'write', 'delete'],
-        { holonId: testHolon, lensName: 'specific-lens' },
-        publicKeyB,
-        { expiresIn: 3600000, issuerKey: privateKeyA }
-      );
-
-      // Token is valid for specific-lens
-      const validForSpecific = await holosphereB.verifyCapability(token, 'read', {
-        holonId: testHolon,
-        lensName: 'specific-lens'
-      });
-      expect(validForSpecific).toBe(true);
-
-      // Token is NOT valid for different-lens
-      const validForDifferent = await holosphereB.verifyCapability(token, 'read', {
-        holonId: testHolon,
-        lensName: 'different-lens'
-      });
-      expect(validForDifferent).toBe(false);
-
-      // Token is NOT valid for different holon
-      const validForDifferentHolon = await holosphereB.verifyCapability(token, 'read', {
-        holonId: testHolon2,
-        lensName: 'specific-lens'
-      });
-      expect(validForDifferentHolon).toBe(false);
-    });
-
-    it('should enforce permission restrictions', async () => {
-      // Issue read-only token
-      const readOnlyToken = await holosphereA.issueCapability(
-        ['read'],
-        { holonId: testHolon, lensName: 'read-only' },
-        publicKeyB,
-        { expiresIn: 3600000, issuerKey: privateKeyA }
-      );
-
-      // Has read
-      expect(await holosphereB.verifyCapability(readOnlyToken, 'read', {
-        holonId: testHolon,
-        lensName: 'read-only'
-      })).toBe(true);
-
-      // Does NOT have write
-      expect(await holosphereB.verifyCapability(readOnlyToken, 'write', {
-        holonId: testHolon,
-        lensName: 'read-only'
-      })).toBe(false);
-
-      // Does NOT have delete
-      expect(await holosphereB.verifyCapability(readOnlyToken, 'delete', {
-        holonId: testHolon,
-        lensName: 'read-only'
-      })).toBe(false);
-    });
-
-    it('should have unique nonce per token (replay protection)', async () => {
-      // Issue two tokens with same parameters
-      const token1 = await holosphereA.issueCapability(
-        ['read'],
-        { holonId: testHolon, lensName: 'replay-test' },
-        publicKeyB,
-        { expiresIn: 3600000, issuerKey: privateKeyA }
-      );
-
-      const token2 = await holosphereA.issueCapability(
-        ['read'],
-        { holonId: testHolon, lensName: 'replay-test' },
-        publicKeyB,
-        { expiresIn: 3600000, issuerKey: privateKeyA }
-      );
-
-      // Tokens should be different (different nonces)
-      expect(token1).not.toBe(token2);
-
-      // But both should be valid
-      const valid1 = await holosphereB.verifyCapability(token1, 'read', {
-        holonId: testHolon,
-        lensName: 'replay-test'
-      });
-      const valid2 = await holosphereB.verifyCapability(token2, 'read', {
-        holonId: testHolon,
-        lensName: 'replay-test'
-      });
-
-      expect(valid1).toBe(true);
-      expect(valid2).toBe(true);
-    });
-  });
-});