@dxos/client-services 0.1.23 → 0.1.24-next.6b1f434

package/src/packlets/spaces/data-space-manager.ts

@@ -6,21 +6,23 @@ import assert from 'node:assert';
 
 import { Event, synchronized, trackLeaks } from '@dxos/async';
 import { Context } from '@dxos/context';
+import { getCredentialAssertion } from '@dxos/credentials';
 import {
-  AcceptSpaceOptions,
-  DataServiceSubscriptions,
   MetadataStore,
   SigningContext,
-  SnapshotStore,
   Space,
   spaceGenesis,
   SpaceManager,
-  SnapshotManager
-} from '@dxos/echo-db';
+  DataServiceSubscriptions,
+  SnapshotManager,
+  SnapshotStore
+} from '@dxos/echo-pipeline';
+import { FeedStore } from '@dxos/feed-store';
 import { Keyring } from '@dxos/keyring';
 import { PublicKey } from '@dxos/keys';
 import { log } from '@dxos/log';
 import { ModelFactory } from '@dxos/model-factory';
+import { FeedMessage } from '@dxos/protocols/proto/dxos/echo/feed';
 import { SpaceMetadata } from '@dxos/protocols/proto/dxos/echo/metadata';
 import { Presence } from '@dxos/teleport-extension-presence';
 import { ComplexMap, deferFunction } from '@dxos/util';
@@ -28,6 +30,13 @@ import { ComplexMap, deferFunction } from '@dxos/util';
 import { createAuthProvider } from '../identity';
 import { DataSpace } from './data-space';
 
+const DATA_PIPELINE_READY_TIMEOUT = 3_000;
+
+export type AcceptSpaceOptions = {
+  spaceKey: PublicKey;
+  genesisFeedKey: PublicKey;
+};
+
 @trackLeaks('open', 'close')
 export class DataSpaceManager {
   private readonly _ctx = new Context();
@@ -43,6 +52,7 @@ export class DataSpaceManager {
     private readonly _keyring: Keyring,
     private readonly _signingContext: SigningContext,
     private readonly _modelFactory: ModelFactory,
+    private readonly _feedStore: FeedStore<FeedMessage>,
     private readonly _snapshotStore: SnapshotStore
   ) {}
 
@@ -59,10 +69,18 @@ export class DataSpaceManager {
     for (const spaceMetadata of this._metadataStore.spaces) {
       log('load space', { spaceMetadata });
       const space = await this._constructSpace(spaceMetadata);
-      if (spaceMetadata.latestTimeframe) {
+      await space.initializeDataPipeline();
+      if (spaceMetadata.dataTimeframe) {
         log('waiting for latest timeframe', { spaceMetadata });
-        await space.dataPipelineController.waitUntilTimeframe(spaceMetadata.latestTimeframe);
+        await space.dataPipelineController.pipelineState!.setTargetTimeframe(spaceMetadata.dataTimeframe);
       }
+      await space.dataPipelineController.pipelineState!.waitUntilReachedTargetTimeframe({
+        timeout: DATA_PIPELINE_READY_TIMEOUT
+      });
+      this._dataServiceSubscriptions.registerSpace(
+        space.key,
+        space.dataPipelineController.databaseBackend!.createDataServiceHost()
+      );
     }
   }
 
@@ -92,9 +110,19 @@ export class DataSpaceManager {
     log('creating space...', { spaceKey });
     const space = await this._constructSpace(metadata);
 
-    await spaceGenesis(this._keyring, this._signingContext, space.inner);
+    const credentials = await spaceGenesis(this._keyring, this._signingContext, space.inner);
     await this._metadataStore.addSpace(metadata);
 
+    const memberCredential = credentials[1];
+    assert(getCredentialAssertion(memberCredential)['@type'] === 'dxos.halo.credentials.SpaceMember');
+    await this._signingContext.recordCredential(memberCredential);
+
+    await space.initializeDataPipeline();
+    this._dataServiceSubscriptions.registerSpace(
+      space.key,
+      space.dataPipelineController.databaseBackend!.createDataServiceHost()
+    );
+
     this.updated.emit();
     return space;
   }
@@ -106,13 +134,17 @@ export class DataSpaceManager {
 
     const metadata: SpaceMetadata = {
       key: opts.spaceKey,
-      genesisFeedKey: opts.genesisFeedKey,
-      controlFeedKey: opts.controlFeedKey,
-      dataFeedKey: opts.dataFeedKey
+      genesisFeedKey: opts.genesisFeedKey
     };
 
     const space = await this._constructSpace(metadata);
     await this._metadataStore.addSpace(metadata);
+    await space.initializeDataPipeline();
+    this._dataServiceSubscriptions.registerSpace(
+      space.key,
+      space.dataPipelineController.databaseBackend!.createDataServiceHost()
+    );
+
     this.updated.emit();
     return space;
   }
@@ -126,6 +158,10 @@ export class DataSpaceManager {
     });
     const snapshotManager = new SnapshotManager(this._snapshotStore);
 
+    const controlFeed =
+      metadata.controlFeedKey && (await this._feedStore.openFeed(metadata.controlFeedKey, { writable: true }));
+    const dataFeed = metadata.dataFeedKey && (await this._feedStore.openFeed(metadata.dataFeedKey, { writable: true }));
+
     const space: Space = await this._spaceManager.constructSpace({
       metadata,
       swarmIdentity: {
@@ -139,8 +175,11 @@ export class DataSpaceManager {
           presence.createExtension({ remotePeerId: session.remotePeerId })
         );
         session.addExtension('dxos.mesh.teleport.objectsync', snapshotManager.objectSync.createExtension());
+        session.addExtension('dxos.mesh.teleport.notarization', dataSpace.notarizationPlugin.createExtension());
       }
     });
+    controlFeed && space.setControlFeed(controlFeed);
+    dataFeed && space.setDataFeed(dataFeed);
 
     const dataSpace = new DataSpace({
       inner: space,
@@ -149,11 +188,13 @@ export class DataSpaceManager {
       snapshotManager,
       presence,
       memberKey: this._signingContext.identityKey,
+      keyring: this._keyring,
+      feedStore: this._feedStore,
+      signingContext: this._signingContext,
       snapshotId: metadata.snapshot
     });
 
     await dataSpace.open();
-    this._dataServiceSubscriptions.registerSpace(space.key, dataSpace.database.createDataServiceHost());
     this._spaces.set(metadata.key, dataSpace);
     return dataSpace;
   }

package/src/packlets/spaces/data-space.ts

@@ -2,17 +2,29 @@
 // Copyright 2022 DXOS.org
 //
 
-import assert from 'node:assert';
-
 import { trackLeaks } from '@dxos/async';
 import { Context } from '@dxos/context';
-import { Database, DataPipelineControllerImpl, ISpace, MetadataStore, Space, SnapshotManager } from '@dxos/echo-db';
+import { CredentialConsumer } from '@dxos/credentials';
+import { timed } from '@dxos/debug';
+import {
+  DataPipelineControllerImpl,
+  MetadataStore,
+  Space,
+  SigningContext,
+  createMappedFeedWriter,
+  SnapshotManager
+} from '@dxos/echo-pipeline';
+import { FeedStore } from '@dxos/feed-store';
+import { Keyring } from '@dxos/keyring';
 import { PublicKey } from '@dxos/keys';
 import { ModelFactory } from '@dxos/model-factory';
+import { FeedMessage } from '@dxos/protocols/proto/dxos/echo/feed';
+import { AdmittedFeed, Credential } from '@dxos/protocols/proto/dxos/halo/credentials';
 import { Presence } from '@dxos/teleport-extension-presence';
 import { ComplexSet } from '@dxos/util';
 
 import { TrustedKeySetAuthVerifier } from '../identity';
+import { NotarizationPlugin } from './notarization-plugin';
 
 const AUTH_TIMEOUT = 30000;
 
@@ -22,21 +34,35 @@ export type DataSpaceParams = {
   metadataStore: MetadataStore;
   snapshotManager: SnapshotManager;
   presence: Presence;
+  keyring: Keyring;
+  feedStore: FeedStore<FeedMessage>;
+  signingContext: SigningContext;
   memberKey: PublicKey;
   snapshotId?: string | undefined;
 };
 
+const CONTROL_PIPELINE_READY_TIMEFRAME = 3000;
 @trackLeaks('open', 'close')
-export class DataSpace implements ISpace {
+export class DataSpace {
   private readonly _ctx = new Context();
   private readonly _dataPipelineController: DataPipelineControllerImpl;
   private readonly _inner: Space;
   private readonly _presence: Presence;
+  private readonly _keyring: Keyring;
+  private readonly _feedStore: FeedStore<FeedMessage>;
+  private readonly _metadataStore: MetadataStore;
+  private readonly _signingContext: SigningContext;
+  private readonly _notarizationPluginConsumer: CredentialConsumer<NotarizationPlugin>;
+
   public readonly authVerifier: TrustedKeySetAuthVerifier;
 
   constructor(params: DataSpaceParams) {
     this._inner = params.inner;
     this._presence = params.presence;
+    this._keyring = params.keyring;
+    this._feedStore = params.feedStore;
+    this._metadataStore = params.metadataStore;
+    this._signingContext = params.signingContext;
     this._dataPipelineController = new DataPipelineControllerImpl({
       modelFactory: params.modelFactory,
       metadataStore: params.metadataStore,
@@ -46,32 +72,31 @@ export class DataSpace implements ISpace {
       feedInfoProvider: (feedKey) => this._inner.spaceState.feeds.get(feedKey),
       snapshotId: params.snapshotId
     });
+
     this.authVerifier = new TrustedKeySetAuthVerifier({
       trustedKeysProvider: () => new ComplexSet(PublicKey.hash, Array.from(this._inner.spaceState.members.keys())),
       update: this._inner.stateUpdate,
       authTimeout: AUTH_TIMEOUT
     });
+
+    this._notarizationPluginConsumer = this._inner.spaceState.registerProcessor(new NotarizationPlugin());
   }
 
   get key() {
     return this._inner.key;
   }
 
-  get inner() {
-    return this._inner;
-  }
-
   get isOpen() {
     return this._inner.isOpen;
   }
 
-  get dataPipelineController(): DataPipelineControllerImpl {
-    return this._dataPipelineController;
+  // TODO(burdon): Can we mark this for debugging only?
+  get inner() {
+    return this._inner;
   }
 
-  get database(): Database {
-    assert(this._dataPipelineController.database);
-    return this._dataPipelineController.database;
+  get dataPipelineController(): DataPipelineControllerImpl {
+    return this._dataPipelineController;
   }
 
   get stateUpdate() {
@@ -82,15 +107,89 @@ export class DataSpace implements ISpace {
     return this._presence;
   }
 
+  get notarizationPlugin() {
+    return this._notarizationPluginConsumer.processor;
+  }
+
   async open() {
+    await this.notarizationPlugin.open();
+    await this._notarizationPluginConsumer.open();
     await this._inner.open();
-    await this._inner.initDataPipeline(this._dataPipelineController);
   }
 
   async close() {
     await this._ctx.dispose();
+
     await this.authVerifier.close();
+
     await this._inner.close();
+    await this._notarizationPluginConsumer.close();
+    await this.notarizationPlugin.close();
+
     await this._presence.destroy();
   }
+
+  async initializeDataPipeline() {
+    await this._inner.controlPipeline.state.waitUntilReachedTargetTimeframe({
+      timeout: CONTROL_PIPELINE_READY_TIMEFRAME
+    });
+
+    await this._createWritableFeeds();
+    this.notarizationPlugin.setWriter(
+      createMappedFeedWriter<Credential, FeedMessage.Payload>(
+        (credential) => ({
+          credential: { credential }
+        }),
+        this._inner.controlPipeline.writer
+      )
+    );
+
+    await this._inner.initDataPipeline(this._dataPipelineController);
+  }
+
+  @timed(10_000)
+  private async _createWritableFeeds() {
+    const credentials: Credential[] = [];
+    if (!this.inner.controlFeedKey) {
+      const controlFeed = await this._feedStore.openFeed(await this._keyring.createKey(), { writable: true });
+      this.inner.setControlFeed(controlFeed);
+
+      credentials.push(
+        await this._signingContext.credentialSigner.createCredential({
+          subject: controlFeed.key,
+          assertion: {
+            '@type': 'dxos.halo.credentials.AdmittedFeed',
+            spaceKey: this.key,
+            deviceKey: this._signingContext.deviceKey,
+            identityKey: this._signingContext.identityKey,
+            designation: AdmittedFeed.Designation.CONTROL
+          }
+        })
+      );
+    }
+    if (!this.inner.dataFeedKey) {
+      const dataFeed = await this._feedStore.openFeed(await this._keyring.createKey(), { writable: true });
+      this.inner.setDataFeed(dataFeed);
+
+      credentials.push(
+        await this._signingContext.credentialSigner.createCredential({
+          subject: dataFeed.key,
+          assertion: {
+            '@type': 'dxos.halo.credentials.AdmittedFeed',
+            spaceKey: this.key,
+            deviceKey: this._signingContext.deviceKey,
+            identityKey: this._signingContext.identityKey,
+            designation: AdmittedFeed.Designation.DATA
+          }
+        })
+      );
+    }
+
+    if (credentials.length > 0) {
+      await this.notarizationPlugin.notarize(credentials);
+    }
+
+    // Set this after credentials are notarized so that on failure we will retry.
+    await this._metadataStore.setWritableFeedKeys(this.key, this.inner.controlFeedKey!, this.inner.dataFeedKey!);
+  }
 }

package/src/packlets/spaces/notarization-plugin.test.ts

@@ -0,0 +1,81 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import { expect } from 'chai';
+
+import { Context } from '@dxos/context';
+import { CredentialGenerator } from '@dxos/credentials';
+import { MockFeedWriter } from '@dxos/feed-store/testing';
+import { Keyring } from '@dxos/keyring';
+import { log } from '@dxos/log';
+import { AdmittedFeed, Credential } from '@dxos/protocols/proto/dxos/halo/credentials';
+import { TestBuilder, TestConnection, TestPeer } from '@dxos/teleport/testing';
+import { afterTest, describe, test } from '@dxos/test';
+
+import { NotarizationPlugin } from './notarization-plugin';
+
+class TestAgent extends TestPeer {
+  private readonly _ctx = new Context();
+
+  feed = new MockFeedWriter<Credential>();
+  notarizationPlugin = new NotarizationPlugin();
+
+  constructor() {
+    super();
+    this.feed.written.on(this._ctx, async ([credential]) => {
+      log('written to feed', { credential });
+      await this.notarizationPlugin.process(credential);
+    });
+  }
+
+  enableWriting() {
+    this.notarizationPlugin.setWriter(this.feed);
+  }
+
+  protected override onOpen(connection: TestConnection): Promise<void> {
+    log('onOpen');
+    connection.teleport.addExtension('dxos.mesh.teleport.notarization', this.notarizationPlugin.createExtension());
+    return super.onOpen(connection);
+  }
+
+  override async destroy(): Promise<void> {
+    await this._ctx.dispose();
+    await super.destroy();
+    await this.notarizationPlugin.close();
+  }
+}
+
+describe('NotarizationPlugin', () => {
+  test('notarize single credential', async () => {
+    const testBuilder = new TestBuilder();
+    afterTest(() => testBuilder.destroy());
+
+    // peer0 is there to test retries.
+    const [_peer0, peer1, peer2] = await testBuilder.createPeers({ factory: () => new TestAgent() });
+    peer1.enableWriting();
+
+    peer1.feed.written.on(async ([credential]) => {
+      log('mock replication', { credential });
+      await peer2.feed.write(credential);
+    });
+
+    await testBuilder.connect(_peer0, peer2);
+
+    const keyring = new Keyring();
+    const generator = new CredentialGenerator(keyring, await keyring.createKey(), await keyring.createKey());
+    const credential = await generator.createFeedAdmission(
+      await keyring.createKey(),
+      await keyring.createKey(),
+      AdmittedFeed.Designation.CONTROL
+    );
+
+    const notarized = peer2.notarizationPlugin.notarize([credential]);
+
+    await testBuilder.connect(peer1, peer2);
+    await notarized;
+
+    expect(peer1.feed.messages.map((c) => c.id)).to.deep.eq([credential.id]);
+    expect(peer2.feed.messages.map((c) => c.id)).to.deep.eq([credential.id]);
+  });
+});

package/src/packlets/spaces/notarization-plugin.ts

@@ -0,0 +1,211 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import assert from 'node:assert';
+
+import { DeferredTask, Event, scheduleTask, TimeoutError, Trigger } from '@dxos/async';
+import { Context } from '@dxos/context';
+import { CredentialProcessor } from '@dxos/credentials';
+import { FeedWriter } from '@dxos/feed-store';
+import { PublicKey } from '@dxos/keys';
+import { log } from '@dxos/log';
+import { schema } from '@dxos/protocols';
+import { Credential } from '@dxos/protocols/proto/dxos/halo/credentials';
+import { NotarizationService, NotarizeRequest } from '@dxos/protocols/proto/dxos/mesh/teleport/notarization';
+import { ExtensionContext, RpcExtension } from '@dxos/teleport';
+import { ComplexMap, ComplexSet, entry } from '@dxos/util';
+
+const RETRY_TIMEOUT = 1000;
+const NOTARIZE_TIMEOUT = 10_000;
+
+/**
+ * See NotarizationService proto.
+ */
+export class NotarizationPlugin implements CredentialProcessor {
+  private readonly _ctx = new Context();
+  private readonly _extensionOpened = new Event();
+
+  private _writer: FeedWriter<Credential> | undefined;
+  private readonly _extensions = new Set<NotarizationTeleportExtension>();
+  private readonly _processedCredentials = new ComplexSet<PublicKey>(PublicKey.hash);
+  private readonly _processCredentialsTriggers = new ComplexMap<PublicKey, Trigger>(PublicKey.hash);
+
+  async open() {}
+
+  async close() {
+    await this._ctx.dispose();
+  }
+
+  /**
+   * Request credentials to be notarized.
+   */
+  async notarize(credentials: Credential[]) {
+    log('notarize', { credentials });
+    assert(
+      credentials.every((credential) => credential.id),
+      'Credentials must have an id'
+    );
+
+    const errors = new Trigger();
+    const ctx = this._ctx.derive({
+      onError: (err) => {
+        log.warn('Notarization error', { err });
+        void ctx.dispose();
+        errors.throw(err);
+      }
+    });
+    scheduleTask(
+      ctx,
+      () => {
+        log.warn('Notarization timeout');
+        void ctx.dispose();
+        errors.throw(new TimeoutError(NOTARIZE_TIMEOUT, 'Notarization timed out'));
+      },
+      NOTARIZE_TIMEOUT
+    );
+
+    const allNotarized = Promise.all(credentials.map((credential) => this._waitUntilProcessed(credential.id!)));
+
+    const peersTried = new Set<NotarizationTeleportExtension>();
+
+    // Repeatable task that tries to notarize credentials with one of the available peers.
+    const notarizeTask = new DeferredTask(ctx, async () => {
+      try {
+        if (this._extensions.size === 0) {
+          log.warn('No peers to notarize with');
+          return; // No peers to try.
+        }
+
+        // Pick a peer that we haven't tried yet.
+        const peer = [...this._extensions].find((peer) => !peersTried.has(peer));
+        if (!peer) {
+          log.warn('Exhausted all peers to notarize with', { retryIn: RETRY_TIMEOUT });
+          peersTried.clear();
+          scheduleTask(ctx, () => notarizeTask.schedule(), RETRY_TIMEOUT); // retry with all peers again
+          return;
+        }
+
+        peersTried.add(peer);
+        log('try notarizing', { peer: peer.localPeerId, credentialId: credentials.map((credential) => credential.id) });
+        await peer.rpc.NotarizationService.notarize({
+          credentials: credentials.filter((credential) => !this._processedCredentials.has(credential.id!))
+        });
+        log('success');
+      } catch (err) {
+        log.warn('error notarizing (recoverable)', err);
+        notarizeTask.schedule(); // retry immediately with next peer
+      }
+    });
+
+    notarizeTask.schedule();
+    this._extensionOpened.on(ctx, () => notarizeTask.schedule());
+
+    try {
+      // TODO(dmaretskyi): Abort (context) & timeout.
+      await Promise.race([allNotarized, errors.wait()]);
+      log('done');
+    } finally {
+      await ctx.dispose();
+    }
+  }
+
+  /**
+   * Called with credentials arriving from the control pipeline.
+   */
+  async process(credential: Credential) {
+    if (!credential.id) {
+      return;
+    }
+    this._processCredentialsTriggers.get(credential.id)?.wake();
+    this._processedCredentials.add(credential.id);
+    this._processCredentialsTriggers.delete(credential.id);
+  }
+
+  setWriter(writer: FeedWriter<Credential>) {
+    assert(!this._writer, 'Writer already set.');
+    this._writer = writer;
+  }
+
+  private async _waitUntilProcessed(id: PublicKey) {
+    if (this._processedCredentials.has(id)) {
+      return;
+    }
+    await entry(this._processCredentialsTriggers, id).orInsert(new Trigger()).value.wait();
+  }
+
+  /**
+   * Requests from other peers to notarize credentials.
+   */
+  private async _onNotarize(request: NotarizeRequest) {
+    if (!this._writer) {
+      throw new Error('Writer not set');
+    }
+    for (const credential of request.credentials ?? []) {
+      assert(credential.id, 'Credential must have an id');
+      if (this._processedCredentials.has(credential.id)) {
+        continue;
+      }
+      await this._writer.write(credential);
+    }
+  }
+
+  createExtension() {
+    const extension = new NotarizationTeleportExtension({
+      onOpen: async () => {
+        log('extension opened', { peer: extension.localPeerId });
+        this._extensions.add(extension);
+        this._extensionOpened.emit();
+      },
+      onClose: async () => {
+        log('extension closed', { peer: extension.localPeerId });
+        this._extensions.delete(extension);
+      },
+      onNotarize: this._onNotarize.bind(this)
+    });
+    return extension;
+  }
+}
+
+export type NotarizationTeleportExtensionParams = {
+  onOpen: () => Promise<void>;
+  onClose: () => Promise<void>;
+  onNotarize: (request: NotarizeRequest) => Promise<void>;
+};
+
+export class NotarizationTeleportExtension extends RpcExtension<Services, Services> {
+  constructor(private readonly _params: NotarizationTeleportExtensionParams) {
+    super({
+      requested: {
+        NotarizationService: schema.getService('dxos.mesh.teleport.notarization.NotarizationService')
+      },
+      exposed: {
+        NotarizationService: schema.getService('dxos.mesh.teleport.notarization.NotarizationService')
+      }
+    });
+  }
+
+  protected async getHandlers(): Promise<Services> {
+    return {
+      NotarizationService: {
+        notarize: async (request) => {
+          await this._params.onNotarize(request);
+        }
+      }
+    };
+  }
+
+  override async onOpen(ctx: ExtensionContext) {
+    await super.onOpen(ctx);
+    await this._params.onOpen();
+  }
+
+  override async onClose(err?: Error | undefined) {
+    await this._params.onClose();
+    await super.onClose(err);
+  }
+}
+
+type Services = {
+  NotarizationService: NotarizationService;
+};

package/src/packlets/spaces/spaces-service.ts

@@ -5,13 +5,14 @@
 import { scheduleTask } from '@dxos/async';
 import { Stream } from '@dxos/codec-protobuf';
 import { raise } from '@dxos/debug';
-import { SpaceManager, SpaceNotFoundError } from '@dxos/echo-db';
+import { SpaceManager, SpaceNotFoundError } from '@dxos/echo-pipeline';
 import {
   QueryCredentialsRequest,
   QueryMembersRequest,
   QueryMembersResponse,
   Space,
-  SpacesService
+  SpacesService,
+  WriteCredentialsRequest
 } from '@dxos/protocols/proto/dxos/client/services';
 import { Credential } from '@dxos/protocols/proto/dxos/halo/credentials';
 
@@ -46,4 +47,11 @@ export class SpacesServiceImpl implements SpacesService {
       scheduleTask(ctx, () => processor.open());
     });
   }
+
+  async writeCredentials({ spaceKey, credentials }: WriteCredentialsRequest) {
+    const space = this._spaceManager.spaces.get(spaceKey) ?? raise(new SpaceNotFoundError(spaceKey));
+    for (const credential of credentials ?? []) {
+      await space.controlPipeline.writer.write({ credential: { credential } });
+    }
+  }
 }

package/src/packlets/testing/credential-utils.ts

@@ -0,0 +1,28 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import { createCredential } from '@dxos/credentials';
+import { Signer } from '@dxos/crypto';
+import { PublicKey } from '@dxos/keys';
+import { Credential } from '@dxos/protocols/proto/dxos/halo/credentials';
+
+export const createMockCredential = async ({
+  signer,
+  issuer
+}: {
+  signer: Signer;
+  issuer: PublicKey;
+}): Promise<Credential> =>
+  createCredential({
+    signer,
+    issuer,
+    subject: new PublicKey(Buffer.from('test')),
+    assertion: {
+      '@type': 'example.testing.rpc.MessageWithAny',
+      payload: {
+        '@type': 'google.protobuf.Any',
+        value: Buffer.from('test')
+      }
+    }
+  });