@dxos/edge-client 0.6.13 → 0.6.14-main.1366248

package/dist/types/src/persistent-lifecycle.d.ts

@@ -1,14 +1,14 @@
 import { Resource } from '@dxos/context';
-export type PersistentLifecycleParams = {
+export type PersistentLifecycleParams<T> = {
     /**
      * Create connection.
      * If promise resolves successfully, connection is considered established.
      */
-    start: () => Promise<void>;
+    start: () => Promise<T | undefined>;
     /**
      * Reset connection to initial state.
      */
-    stop: () => Promise<void>;
+    stop: (state: T) => Promise<void>;
     /**
      * Called after successful start.
      */
@@ -23,17 +23,19 @@ export type PersistentLifecycleParams = {
  * Handles restarts (e.g. persists connection).
  * Restarts are scheduled with exponential backoff.
  */
-export declare class PersistentLifecycle extends Resource {
+export declare class PersistentLifecycle<T> extends Resource {
     private readonly _start;
     private readonly _stop;
     private readonly _onRestart?;
     private readonly _maxRestartDelay;
+    private _currentContext;
     private _restartTask?;
     private _restartAfter;
-    constructor({ start, stop, onRestart, maxRestartDelay }: PersistentLifecycleParams);
+    constructor({ start, stop, onRestart, maxRestartDelay }: PersistentLifecycleParams<T>);
     protected _open(): Promise<void>;
     protected _close(): Promise<void>;
     private _restart;
+    private _stopCurrentContext;
     /**
      * Scheduling restart should be done from outside.
      */

package/dist/types/src/persistent-lifecycle.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"persistent-lifecycle.d.ts","sourceRoot":"","sources":["../../../src/persistent-lifecycle.ts"],"names":[],"mappings":"AAKA,OAAO,EAAqC,QAAQ,EAAE,MAAM,eAAe,CAAC;AAO5E,MAAM,MAAM,yBAAyB,GAAG;IACtC;;;OAGG;IACH,KAAK,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAE3B;;OAEG;IACH,IAAI,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAE1B;;OAEG;IACH,SAAS,CAAC,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAEhC;;;OAGG;IACH,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B,CAAC;AAEF;;;GAGG;AACH,qBAAa,mBAAoB,SAAQ,QAAQ;IAC/C,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAsB;IAC7C,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAsB;IAC5C,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAsB;IAClD,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAS;IAE1C,OAAO,CAAC,YAAY,CAAC,CAA2B;IAChD,OAAO,CAAC,aAAa,CAAK;gBAEd,EAAE,KAAK,EAAE,IAAI,EAAE,SAAS,EAAE,eAA2C,EAAE,EAAE,yBAAyB;cASrF,KAAK;cAeL,MAAM;YAMjB,QAAQ;IAgBtB;;OAEG;IAEH,eAAe;CAMhB"}
+{"version":3,"file":"persistent-lifecycle.d.ts","sourceRoot":"","sources":["../../../src/persistent-lifecycle.ts"],"names":[],"mappings":"AAKA,OAAO,EAAqC,QAAQ,EAAE,MAAM,eAAe,CAAC;AAO5E,MAAM,MAAM,yBAAyB,CAAC,CAAC,IAAI;IACzC;;;OAGG;IACH,KAAK,EAAE,MAAM,OAAO,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC;IAEpC;;OAEG;IACH,IAAI,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAElC;;OAEG;IACH,SAAS,CAAC,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAEhC;;;OAGG;IACH,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B,CAAC;AAEF;;;GAGG;AACH,qBAAa,mBAAmB,CAAC,CAAC,CAAE,SAAQ,QAAQ;IAClD,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA+B;IACtD,OAAO,CAAC,QAAQ,CAAC,KAAK,CAA8B;IACpD,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAsB;IAClD,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAS;IAE1C,OAAO,CAAC,eAAe,CAA4B;IACnD,OAAO,CAAC,YAAY,CAAC,CAA2B;IAChD,OAAO,CAAC,aAAa,CAAK;gBAEd,EAAE,KAAK,EAAE,IAAI,EAAE,SAAS,EAAE,eAA2C,EAAE,EAAE,yBAAyB,CAAC,CAAC,CAAC;cASxF,KAAK;cAgBL,MAAM;YAMjB,QAAQ;YAkBR,mBAAmB;IAWjC;;OAEG;IAEH,eAAe;CAMhB"}

package/dist/types/src/protocol.d.ts

@@ -1,6 +1,6 @@
 import { buf } from '@dxos/protocols/buf';
-import { type Message, type Peer as PeerProto } from '@dxos/protocols/buf/dxos/edge/messenger_pb';
-export type PeerData = Partial<PeerProto>;
+import { type Message, type PeerSchema } from '@dxos/protocols/buf/dxos/edge/messenger_pb';
+export type PeerData = buf.MessageInitShape<typeof PeerSchema>;
 export declare const getTypename: (typeName: string) => string;
 /**
  * NOTE: The type registry should be extended with all message types.

package/dist/types/src/protocol.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"protocol.d.ts","sourceRoot":"","sources":["../../../src/protocol.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,GAAG,EAAU,MAAM,qBAAqB,CAAC;AAClD,OAAO,EAAE,KAAK,OAAO,EAAiB,KAAK,IAAI,IAAI,SAAS,EAAE,MAAM,4CAA4C,CAAC;AAGjH,MAAM,MAAM,QAAQ,GAAG,OAAO,CAAC,SAAS,CAAC,CAAC;AAE1C,eAAO,MAAM,WAAW,aAAc,MAAM,WAAsC,CAAC;AAEnF;;GAEG;AACH,qBAAa,QAAQ;IACnB,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAe;gBAEjC,KAAK,EAAE,GAAG,CAAC,WAAW,EAAE;IAIpC,IAAI,YAAY,IAAI,GAAG,CAAC,QAAQ,CAE/B;IAED,MAAM,CAAC,OAAO,EAAE,OAAO,GAAG,GAAG;IAQ7B;;OAEG;IACH,UAAU,CAAC,IAAI,SAAS,GAAG,CAAC,WAAW,EAAE,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,IAAI,GAAG,GAAG,CAAC,YAAY,CAAC,IAAI,CAAC;IAa9F;;OAEG;IACH,cAAc,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS;IASpD;;OAEG;IACH,aAAa,CAAC,IAAI,SAAS,GAAG,CAAC,WAAW,EACxC,IAAI,EAAE,IAAI,EACV,EACE,MAAM,EACN,MAAM,EACN,OAAO,EACP,SAAS,GACV,EAAE;QACD,MAAM,CAAC,EAAE,QAAQ,CAAC;QAClB,MAAM,CAAC,EAAE,QAAQ,EAAE,CAAC;QACpB,OAAO,CAAC,EAAE,GAAG,CAAC,gBAAgB,CAAC,IAAI,CAAC,CAAC;QACrC,SAAS,CAAC,EAAE,MAAM,CAAC;KACpB;CAUJ;AAED;;GAEG;AACH,eAAO,MAAM,YAAY,SAAgB,GAAG,KAAG,OAAO,CAAC,UAAU,CAYhE,CAAC"}
+{"version":3,"file":"protocol.d.ts","sourceRoot":"","sources":["../../../src/protocol.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,GAAG,EAAU,MAAM,qBAAqB,CAAC;AAClD,OAAO,EAAE,KAAK,OAAO,EAAiB,KAAK,UAAU,EAAE,MAAM,4CAA4C,CAAC;AAG1G,MAAM,MAAM,QAAQ,GAAG,GAAG,CAAC,gBAAgB,CAAC,OAAO,UAAU,CAAC,CAAC;AAE/D,eAAO,MAAM,WAAW,aAAc,MAAM,WAAsC,CAAC;AAEnF;;GAEG;AACH,qBAAa,QAAQ;IACnB,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAe;gBAEjC,KAAK,EAAE,GAAG,CAAC,WAAW,EAAE;IAIpC,IAAI,YAAY,IAAI,GAAG,CAAC,QAAQ,CAE/B;IAED,MAAM,CAAC,OAAO,EAAE,OAAO,GAAG,GAAG;IAQ7B;;OAEG;IACH,UAAU,CAAC,IAAI,SAAS,GAAG,CAAC,WAAW,EAAE,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,IAAI,GAAG,GAAG,CAAC,YAAY,CAAC,IAAI,CAAC;IAa9F;;OAEG;IACH,cAAc,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS;IASpD;;OAEG;IACH,aAAa,CAAC,IAAI,SAAS,GAAG,CAAC,WAAW,EACxC,IAAI,EAAE,IAAI,EACV,EACE,MAAM,EACN,MAAM,EACN,OAAO,EACP,SAAS,GACV,EAAE;QACD,MAAM,CAAC,EAAE,QAAQ,CAAC;QAClB,MAAM,CAAC,EAAE,QAAQ,EAAE,CAAC;QACpB,OAAO,CAAC,EAAE,GAAG,CAAC,gBAAgB,CAAC,IAAI,CAAC,CAAC;QACrC,SAAS,CAAC,EAAE,MAAM,CAAC;KACpB;CAUJ;AAED;;GAEG;AACH,eAAO,MAAM,YAAY,SAAgB,GAAG,KAAG,OAAO,CAAC,UAAU,CAYhE,CAAC"}

package/dist/types/src/testing/index.d.ts

@@ -0,0 +1,2 @@
+export * from './test-utils';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/src/testing/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/testing/index.ts"],"names":[],"mappings":"AAIA,cAAc,cAAc,CAAC"}

package/dist/types/src/testing/test-utils.d.ts

@@ -0,0 +1,22 @@
+import WebSocket from 'isomorphic-ws';
+import { Trigger } from '@dxos/async';
+import { type Message } from '@dxos/protocols/buf/dxos/edge/messenger_pb';
+export declare const DEFAULT_PORT = 8080;
+type TestEdgeWsServerParams = {
+    admitConnection?: Trigger;
+    payloadDecoder?: (payload: Uint8Array) => any;
+    messageHandler?: (payload: any) => Promise<Uint8Array | undefined>;
+};
+export declare const createTestEdgeWsServer: (port?: number, params?: TestEdgeWsServerParams) => Promise<{
+    server: WebSocket.Server;
+    messageSink: any[];
+    messageSourceLog: any[];
+    endpoint: string;
+    cleanup: () => void;
+    currentConnection: () => WebSocket | undefined;
+    sendResponseMessage: (request: Message, responsePayload: Uint8Array) => void;
+    sendMessage: (msg: Message) => void;
+    closeConnection: () => Promise<void>;
+}>;
+export {};
+//# sourceMappingURL=test-utils.d.ts.map

package/dist/types/src/testing/test-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-utils.d.ts","sourceRoot":"","sources":["../../../../src/testing/test-utils.ts"],"names":[],"mappings":"AAIA,OAAO,SAAS,MAAM,eAAe,CAAC;AAEtC,OAAO,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAGtC,OAAO,EAAoC,KAAK,OAAO,EAAE,MAAM,4CAA4C,CAAC;AAK5G,eAAO,MAAM,YAAY,OAAO,CAAC;AAEjC,KAAK,sBAAsB,GAAG;IAC5B,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,cAAc,CAAC,EAAE,CAAC,OAAO,EAAE,UAAU,KAAK,GAAG,CAAC;IAC9C,cAAc,CAAC,EAAE,CAAC,OAAO,EAAE,GAAG,KAAK,OAAO,CAAC,UAAU,GAAG,SAAS,CAAC,CAAC;CACpE,CAAC;AAEF,eAAO,MAAM,sBAAsB,2BAAwC,sBAAsB;;;;;;;mCAsE9E,OAAO,mBAAmB,UAAU;uBA1BhC,OAAO;;EAS7B,CAAC"}

package/dist/types/src/utils.d.ts

@@ -0,0 +1,2 @@
+export declare const getEdgeUrlWithProtocol: (baseUrl: string, protocol: "http" | "ws") => string;
+//# sourceMappingURL=utils.d.ts.map

package/dist/types/src/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/utils.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,sBAAsB,YAAa,MAAM,YAAY,MAAM,GAAG,IAAI,WAK9E,CAAC"}

package/package.json

@@ -1,23 +1,31 @@
 {
   "name": "@dxos/edge-client",
-  "version": "0.6.13",
+  "version": "0.6.14-main.1366248",
   "description": "EDGE Client",
   "homepage": "https://dxos.org",
   "bugs": "https://github.com/dxos/dxos/issues",
   "license": "MIT",
   "author": "DXOS.org",
+  "sideEffects": true,
   "exports": {
     ".": {
+      "types": "./dist/types/src/index.d.ts",
       "browser": "./dist/lib/browser/index.mjs",
-      "node": {
-        "default": "./dist/lib/node/index.cjs"
-      },
-      "types": "./dist/types/src/index.d.ts"
+      "node": "./dist/lib/node-esm/index.mjs"
+    },
+    "./testing": {
+      "types": "./dist/types/src/testing/index.d.ts",
+      "browser": "./dist/lib/browser/testing/index.mjs",
+      "node": "./dist/lib/node-esm/testing/index.mjs"
     }
   },
   "types": "dist/types/src/index.d.ts",
   "typesVersions": {
-    "*": {}
+    "*": {
+      "testing": [
+        "dist/types/src/testing/index.d.ts"
+      ]
+    }
   },
   "files": [
     "dist",
@@ -25,21 +33,23 @@
     "README.md"
   ],
   "dependencies": {
-    "@bufbuild/protobuf": "^2.0.0",
     "isomorphic-ws": "^5.0.0",
     "ws": "^8.14.2",
-    "@dxos/async": "0.6.13",
-    "@dxos/context": "0.6.13",
-    "@dxos/debug": "0.6.13",
-    "@dxos/log": "0.6.13",
-    "@dxos/invariant": "0.6.13",
-    "@dxos/node-std": "0.6.13",
-    "@dxos/protocols": "0.6.13",
-    "@dxos/util": "0.6.13"
+    "@dxos/async": "0.6.14-main.1366248",
+    "@dxos/context": "0.6.14-main.1366248",
+    "@dxos/crypto": "0.6.14-main.1366248",
+    "@dxos/debug": "0.6.14-main.1366248",
+    "@dxos/invariant": "0.6.14-main.1366248",
+    "@dxos/credentials": "0.6.14-main.1366248",
+    "@dxos/keyring": "0.6.14-main.1366248",
+    "@dxos/log": "0.6.14-main.1366248",
+    "@dxos/node-std": "0.6.14-main.1366248",
+    "@dxos/keys": "0.6.14-main.1366248",
+    "@dxos/protocols": "0.6.14-main.1366248",
+    "@dxos/util": "0.6.14-main.1366248"
   },
   "devDependencies": {
-    "jest-websocket-mock": "^2.5.0",
-    "@dxos/keys": "0.6.13"
+    "@dxos/test-utils": "0.6.14-main.1366248"
   },
   "publishConfig": {
     "access": "public"

package/src/auth.ts

@@ -0,0 +1,135 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import { createCredential, signPresentation } from '@dxos/credentials';
+import { type Signer } from '@dxos/crypto';
+import { Keyring } from '@dxos/keyring';
+import { PublicKey } from '@dxos/keys';
+import { type Chain, type Credential } from '@dxos/protocols/proto/dxos/halo/credentials';
+
+import type { EdgeIdentity } from './edge-identity';
+
+/**
+ * Edge identity backed by a device key without a credential chain.
+ */
+export const createDeviceEdgeIdentity = async (signer: Signer, key: PublicKey): Promise<EdgeIdentity> => {
+  return {
+    identityKey: key.toHex(),
+    peerKey: key.toHex(),
+    presentCredentials: async ({ challenge }) => {
+      return signPresentation({
+        presentation: {
+          credentials: [
+            // Verifier requires at least one credential in the presentation to establish the subject.
+            await createCredential({
+              assertion: {
+                '@type': 'dxos.halo.credentials.Auth',
+              },
+              issuer: key,
+              subject: key,
+              signer,
+            }),
+          ],
+        },
+        signer,
+        signerKey: key,
+        nonce: challenge,
+      });
+    },
+  };
+};
+
+/**
+ * Edge identity backed by a chain of credentials.
+ */
+export const createChainEdgeIdentity = async (
+  signer: Signer,
+  identityKey: PublicKey,
+  peerKey: PublicKey,
+  chain: Chain,
+  credentials: Credential[],
+): Promise<EdgeIdentity> => {
+  const credentialsToSign =
+    credentials.length > 0
+      ? credentials
+      : [
+          await createCredential({
+            assertion: {
+              '@type': 'dxos.halo.credentials.Auth',
+            },
+            issuer: identityKey,
+            subject: identityKey,
+            signer,
+            chain,
+            signingKey: peerKey,
+          }),
+        ];
+
+  return {
+    identityKey: identityKey.toHex(),
+    peerKey: peerKey.toHex(),
+    presentCredentials: async ({ challenge }) => {
+      return signPresentation({
+        presentation: {
+          credentials: credentialsToSign,
+        },
+        signer,
+        nonce: challenge,
+        signerKey: peerKey,
+        chain,
+      });
+    },
+  };
+};
+
+/**
+ * Edge identity backed by a random ephemeral key without HALO.
+ */
+export const createEphemeralEdgeIdentity = async (): Promise<EdgeIdentity> => {
+  const keyring = new Keyring();
+  const key = await keyring.createKey();
+  return createDeviceEdgeIdentity(keyring, key);
+};
+
+/**
+ * Creates a HALO chain of credentials to act as an edge identity.
+ */
+export const createTestHaloEdgeIdentity = async (
+  signer: Signer,
+  identityKey: PublicKey,
+  deviceKey: PublicKey,
+): Promise<EdgeIdentity> => {
+  const deviceAdmission = await createCredential({
+    assertion: {
+      '@type': 'dxos.halo.credentials.AuthorizedDevice',
+      deviceKey,
+      identityKey,
+    },
+    issuer: identityKey,
+    subject: deviceKey,
+    signer,
+  });
+  return createChainEdgeIdentity(signer, identityKey, deviceKey, { credential: deviceAdmission }, [
+    await createCredential({
+      assertion: {
+        '@type': 'dxos.halo.credentials.Auth',
+      },
+      issuer: identityKey,
+      subject: identityKey,
+      signer,
+    }),
+  ]);
+};
+
+export const createStubEdgeIdentity = (): EdgeIdentity => {
+  const identityKey = PublicKey.random();
+  const deviceKey = PublicKey.random();
+  return {
+    identityKey: identityKey.toHex(),
+    peerKey: deviceKey.toHex(),
+    presentCredentials: async () => {
+      throw new Error('Stub identity does not support authentication.');
+    },
+  };
+};

package/src/defs.ts

@@ -2,10 +2,9 @@
 // Copyright 2024 DXOS.org
 //
 
-import { AnySchema } from '@bufbuild/protobuf/wkt';
-
+import { bufWkt } from '@dxos/protocols/buf';
 import { SwarmRequestSchema, SwarmResponseSchema, TextMessageSchema } from '@dxos/protocols/buf/dxos/edge/messenger_pb';
 
 import { Protocol } from './protocol';
 
-export const protocol = new Protocol([SwarmRequestSchema, SwarmResponseSchema, TextMessageSchema, AnySchema]);
+export const protocol = new Protocol([SwarmRequestSchema, SwarmResponseSchema, TextMessageSchema, bufWkt.AnySchema]);

package/src/edge-client.test.ts

@@ -2,49 +2,168 @@
 // Copyright 2024 DXOS.org
 //
 
-import chai, { expect } from 'chai';
-import chaiAsPromised from 'chai-as-promised';
+import { describe, expect, onTestFinished, test } from 'vitest';
 
-import { PublicKey } from '@dxos/keys';
+import { Trigger } from '@dxos/async';
+import { Keyring } from '@dxos/keyring';
 import { TextMessageSchema } from '@dxos/protocols/buf/dxos/edge/messenger_pb';
-import { test, describe, openAndClose } from '@dxos/test';
+import { openAndClose } from '@dxos/test-utils';
 
+import { createEphemeralEdgeIdentity, createTestHaloEdgeIdentity } from './auth';
 import { protocol } from './defs';
 import { EdgeClient } from './edge-client';
-import { createTestWsServer } from './test-utils';
-
-chai.use(chaiAsPromised);
+import { type EdgeIdentity } from './edge-identity';
+import { EdgeConnectionClosedError, EdgeIdentityChangedError } from './errors';
+import { createTestEdgeWsServer } from './testing';
 
 describe('EdgeClient', () => {
-  const textMessage = (message: string) => protocol.createMessage(TextMessageSchema, { payload: { message } });
+  let wsServerPort = 8001;
 
   test('reconnects on error', async () => {
-    const { error: serverError, endpoint } = await createTestWsServer();
-    const id = PublicKey.random().toHex();
-    const client = new EdgeClient(id, id, { socketEndpoint: endpoint });
-    await openAndClose(client);
+    const { closeConnection, endpoint, cleanup } = await createTestEdgeWsServer(wsServerPort++);
+    onTestFinished(cleanup);
+
+    const { client, reconnectTrigger } = await openNewClient(endpoint);
     await client.send(textMessage('Hello world 1'));
     expect(client.isOpen).is.true;
 
-    const reconnected = client.reconnect.waitForCount(1);
-    await serverError();
-    await reconnected;
-    await expect(client.send(textMessage('Hello world 2'))).to.be.fulfilled;
+    reconnectTrigger.reset();
+    await closeConnection();
+    await reconnectTrigger.wait();
+    await expect(client.send(textMessage('Hello world 2'))).resolves.not.toThrow();
+  });
+
+  test('isConnected', async () => {
+    const admitConnection = new Trigger();
+    const { closeConnection, endpoint, cleanup } = await createTestEdgeWsServer(wsServerPort++, { admitConnection });
+    onTestFinished(cleanup);
+
+    const { client } = await openNewClient(endpoint);
+
+    expect(client.isConnected).toBeFalsy();
+    admitConnection.wake();
+    await expect.poll(() => client.isConnected).toBeTruthy();
+
+    admitConnection.reset();
+    await closeConnection();
+    expect(client.isOpen).is.true;
+    await expect.poll(() => client.isConnected).toBeFalsy();
+
+    admitConnection.wake();
+    await expect.poll(() => client.isConnected).toBeTruthy();
   });
 
   test('set identity reconnects', async () => {
-    const { endpoint } = await createTestWsServer();
+    const { endpoint, cleanup } = await createTestEdgeWsServer(wsServerPort++);
+    onTestFinished(cleanup);
 
-    const id = PublicKey.random().toHex();
-    const client = new EdgeClient(id, id, { socketEndpoint: endpoint });
-    await openAndClose(client);
+    const { client, reconnectTrigger } = await openNewClient(endpoint);
     await client.send(textMessage('Hello world 1'));
     expect(client.isOpen).is.true;
 
-    const newId = PublicKey.random().toHex();
-    const reconnected = client.reconnect.waitForCount(1);
-    client.setIdentity({ peerKey: newId, identityKey: newId });
-    await reconnected;
-    await expect(client.send(textMessage('Hello world 2'))).to.be.fulfilled;
+    reconnectTrigger.reset();
+    client.setIdentity(await createEphemeralEdgeIdentity());
+    await reconnectTrigger.wait();
+    await expect(client.send(textMessage('Hello world 2'))).resolves.not.toThrow();
   });
+
+  test('send blocks until connection becomes ready', async () => {
+    const admitConnection = new Trigger();
+    const { endpoint, messageSink, cleanup } = await createTestEdgeWsServer(wsServerPort++, { admitConnection });
+    onTestFinished(cleanup);
+
+    const { client } = await openNewClient(endpoint);
+    setTimeout(() => admitConnection.wake(), 20);
+    await client.send(textMessage('Hello world 1'));
+    await expect.poll(() => messageSink.length).toBe(1);
+  });
+
+  test('send fails if identity changes before connection becomes ready', async () => {
+    const admitConnection = new Trigger();
+    const { endpoint, cleanup, messageSink } = await createTestEdgeWsServer(wsServerPort++, { admitConnection });
+    onTestFinished(cleanup);
+
+    const { client } = await openNewClient(endpoint);
+    setTimeout(async () => client.setIdentity(await createEphemeralEdgeIdentity()));
+    await expect(client.send(textMessage('Hello world 1'))).rejects.toThrow(EdgeIdentityChangedError);
+
+    // Test recovers.
+    setTimeout(() => admitConnection.wake(), 20);
+    await client.send(textMessage('Hello world 1'));
+    await expect.poll(() => messageSink.length).toBe(1);
+  });
+
+  test('send fails if client is closed before connection becomes ready', async () => {
+    const admitConnection = new Trigger();
+    const { endpoint, cleanup } = await createTestEdgeWsServer(wsServerPort++, { admitConnection });
+    onTestFinished(cleanup);
+
+    const { client } = await openNewClient(endpoint);
+    setTimeout(() => client.close());
+    await expect(client.send(textMessage('Hello world 1'))).rejects.toThrow(EdgeConnectionClosedError);
+  });
+
+  test('onReconnect trigger', async () => {
+    const admitConnection = new Trigger();
+    const { endpoint, cleanup, closeConnection } = await createTestEdgeWsServer(wsServerPort++, { admitConnection });
+    onTestFinished(cleanup);
+
+    const { client } = await openNewClient(endpoint);
+    let callCount = 0;
+    client.onReconnected(() => callCount++);
+    admitConnection.wake();
+
+    await expect.poll(() => callCount).toEqual(1);
+    await closeConnection();
+    await expect.poll(() => callCount).toEqual(2);
+
+    const trigger = new Trigger();
+    client.onReconnected(() => trigger.wake());
+    await trigger.wait();
+    expect(callCount).toEqual(2);
+  });
+
+  test('send message right after identity change is delivered successfully with the new identity', async () => {
+    const { endpoint, cleanup, messageSourceLog } = await createTestEdgeWsServer(wsServerPort++);
+    onTestFinished(cleanup);
+
+    const { client, identity: oldIdentity } = await openNewClient(endpoint);
+    await client.send(textMessage('Hello world 1', oldIdentity));
+    expect(client.isOpen).is.true;
+
+    const newIdentity = await createEphemeralEdgeIdentity();
+    client.setIdentity(newIdentity);
+    await client.send(textMessage('Hello world 2', newIdentity));
+    await expect.poll(() => messageSourceLog.length).toBe(2);
+    expect(messageSourceLog.map((m) => m.peerKey)).toStrictEqual([oldIdentity.peerKey, newIdentity.peerKey]);
+  });
+
+  test.skipIf(!process.env.EDGE_ENDPOINT)('connect to local edge server', async () => {
+    // const identity = await createEphemeralEdgeIdentity();
+
+    const keyring = new Keyring();
+    const identity = await createTestHaloEdgeIdentity(keyring, await keyring.createKey(), await keyring.createKey());
+
+    const client = new EdgeClient(identity, { socketEndpoint: process.env.EDGE_ENDPOINT! });
+    await openAndClose(client);
+    await client.send(textMessage('Hello world 1'));
+    expect(client.isOpen).is.true;
+  });
+
+  const textMessage = (message: string, source?: EdgeIdentity) =>
+    protocol.createMessage(TextMessageSchema, {
+      source: source && { peerKey: source.peerKey, identityKey: source.identityKey },
+      payload: { message },
+    });
+
+  const openNewClient = async (endpoint: string) => {
+    const identity = await createEphemeralEdgeIdentity();
+    const client = new EdgeClient(identity, { socketEndpoint: endpoint });
+    await openAndClose(client);
+    const reconnectTrigger = new Trigger();
+    client.onReconnected(() => {
+      reconnectTrigger.wake();
+    });
+    return { client, reconnectTrigger, identity };
+  };
 });