@fhevm/sdk 0.0.1 → 1.0.0-alpha.1

package/core/modules/relayer/module/guards/RelayerResponseFailed.ts

@@ -0,0 +1,244 @@
+import type {
+  RelayerApiError,
+  RelayerApiError400,
+  RelayerApiError400NoDetails,
+  RelayerApiError400WithDetails,
+  RelayerApiError404,
+  RelayerApiError429,
+  RelayerApiError500,
+  RelayerApiError503,
+  RelayerResponseFailed,
+} from '../../../../types/relayer-p.js';
+import type { ErrorMetadataParams } from '../../../../base/errors/ErrorBase.js';
+import { assertRecordNonNullableProperty } from '../../../../base/record.js';
+import { assertRecordStringProperty } from '../../../../base/string.js';
+import { assertIsRelayerApiError400NoDetails } from './api-errors/RelayerApiError400NoDetails.js';
+import { assertIsRelayerApiError400WithDetails } from './api-errors/RelayerApiError400WithDetails.js';
+import { assertIsRelayerApiError404 } from './api-errors/RelayerApiError404.js';
+import { assertIsRelayerApiError429 } from './api-errors/RelayerApiError429.js';
+import { assertIsRelayerApiError500 } from './api-errors/RelayerApiError500.js';
+import { assertIsRelayerApiError503 } from './api-errors/RelayerApiError503.js';
+import { InvalidPropertyError } from '../../../../base/errors/InvalidPropertyError.js';
+
+/**
+ * Asserts that `value` matches the {@link RelayerResponseFailed} schema:
+ * ```json
+ * {
+ *   "status": "failed",
+ *   "error": { ... }
+ * }
+ * ```
+ * Where `error` is a {@link RelayerApiError}.
+ */
+export function assertIsRelayerResponseFailed(
+  value: unknown,
+  name: string,
+  options: ErrorMetadataParams,
+): asserts value is RelayerResponseFailed {
+  type T = RelayerResponseFailed;
+  assertRecordStringProperty(value, 'status' satisfies keyof T, name, {
+    expectedValue: 'failed' satisfies T['status'],
+    ...options,
+  });
+  assertRecordNonNullableProperty(value, 'error' satisfies keyof T, name, options);
+  assertIsRelayerApiError(value.error, `${name}.error`, options);
+}
+
+/**
+ * Asserts that `value` matches one of the {@link RelayerApiError} schemas,
+ * dispatching by `label`:
+ * - 400: {@link RelayerApiError400NoDetails} or {@link RelayerApiError400WithDetails}
+ * - 404: {@link RelayerApiError404}
+ * - 429: {@link RelayerApiError429}
+ * - 500: {@link RelayerApiError500}
+ * - 503: {@link RelayerApiError503}
+ */
+export function assertIsRelayerApiError(
+  value: unknown,
+  name: string,
+  options: ErrorMetadataParams,
+): asserts value is RelayerApiError {
+  assertRecordStringProperty(value, 'label', name, {});
+  // 400
+  if (
+    value.label === ('malformed_json' satisfies RelayerApiError400NoDetails['label']) ||
+    value.label === ('request_error' satisfies RelayerApiError400NoDetails['label']) ||
+    value.label === ('not_ready_for_decryption' satisfies RelayerApiError400NoDetails['label'])
+  ) {
+    assertIsRelayerApiError400NoDetails(value, name, options);
+  }
+  // 400 (with details)
+  else if (
+    value.label === ('missing_fields' satisfies RelayerApiError400WithDetails['label']) ||
+    value.label === ('validation_failed' satisfies RelayerApiError400WithDetails['label'])
+  ) {
+    assertIsRelayerApiError400WithDetails(value, name, options);
+  }
+  // 404
+  else if (value.label === ('not_found' satisfies RelayerApiError404['label'])) {
+    assertIsRelayerApiError404(value, name, options);
+  }
+  // 429
+  else if (
+    value.label === ('rate_limited' satisfies RelayerApiError429['label']) ||
+    value.label === ('protocol_overload' satisfies RelayerApiError429['label'])
+  ) {
+    assertIsRelayerApiError429(value, name, options);
+  }
+  // 500
+  else if (value.label === ('internal_server_error' satisfies RelayerApiError500['label'])) {
+    assertIsRelayerApiError500(value, name, options);
+  }
+  // 503
+  else if (
+    value.label === ('readiness_check_timed_out' satisfies RelayerApiError503['label']) ||
+    value.label === ('response_timed_out' satisfies RelayerApiError503['label']) ||
+    value.label === ('protocol_paused' satisfies RelayerApiError503['label']) ||
+    value.label === ('gateway_not_reachable' satisfies RelayerApiError503['label'])
+  ) {
+    assertIsRelayerApiError503(value, name, options);
+  }
+  // Unsupported
+  else {
+    throw new InvalidPropertyError(
+      {
+        subject: name,
+        property: 'label',
+        expectedType: 'string',
+        expectedValue: [
+          'malformed_json',
+          'request_error',
+          'not_ready_for_decryption',
+          'missing_fields',
+          'validation_failed',
+          'rate_limited',
+          'internal_server_error',
+          'protocol_paused',
+          'protocol_overload',
+          'gateway_not_reachable',
+          'readiness_check_timed_out',
+          'response_timed_out',
+        ],
+        type: typeof value.label,
+        value: value.label,
+      },
+      options,
+    );
+  }
+}
+
+/**
+ * Asserts that `value` matches the failed response with 400 error schema:
+ * ```json
+ * {
+ *   "status": "failed",
+ *   "error": RelayerApiError400NoDetails | RelayerApiError400WithDetails
+ * }
+ * ```
+ * @see {@link assertIsRelayerApiError400NoDetails}
+ * @see {@link assertIsRelayerApiError400WithDetails}
+ */
+export function assertIsRelayerResponseFailedWithError400(
+  value: unknown,
+  name: string,
+  options: ErrorMetadataParams,
+): asserts value is {
+  status: 'failed';
+  error: RelayerApiError400;
+} {
+  assertIsRelayerResponseFailed(value, name, options);
+  if (
+    value.error.label === ('malformed_json' satisfies RelayerApiError400NoDetails['label']) ||
+    value.error.label === ('request_error' satisfies RelayerApiError400NoDetails['label']) ||
+    value.error.label === ('not_ready_for_decryption' satisfies RelayerApiError400NoDetails['label'])
+  ) {
+    assertIsRelayerApiError400NoDetails(value.error, `${name}.error`, options);
+  } else if (
+    value.error.label === ('missing_fields' satisfies RelayerApiError400WithDetails['label']) ||
+    value.error.label === ('validation_failed' satisfies RelayerApiError400WithDetails['label'])
+  ) {
+    assertIsRelayerApiError400WithDetails(value.error, `${name}.error`, options);
+  } else {
+    throw new InvalidPropertyError(
+      {
+        subject: `${name}.error`,
+        property: 'label',
+        expectedType: 'string',
+        expectedValue: [
+          'malformed_json',
+          'request_error',
+          'not_ready_for_decryption',
+          'missing_fields',
+          'validation_failed',
+        ],
+        type: typeof value.error.label,
+        value: value.error.label,
+      },
+      options,
+    );
+  }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// 404
+////////////////////////////////////////////////////////////////////////////////
+
+export function assertIsRelayerResponseFailedWithError404(
+  value: unknown,
+  name: string,
+  options: ErrorMetadataParams,
+): asserts value is {
+  status: 'failed';
+  error: RelayerApiError404;
+} {
+  assertIsRelayerResponseFailed(value, name, options);
+  assertIsRelayerApiError404(value.error, `${name}.error`, options);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// 429
+////////////////////////////////////////////////////////////////////////////////
+
+export function assertIsRelayerResponseFailedWithError429(
+  value: unknown,
+  name: string,
+  options: ErrorMetadataParams,
+): asserts value is {
+  status: 'failed';
+  error: RelayerApiError429;
+} {
+  assertIsRelayerResponseFailed(value, name, options);
+  assertIsRelayerApiError429(value.error, `${name}.error`, options);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// 500
+////////////////////////////////////////////////////////////////////////////////
+
+export function assertIsRelayerResponseFailedWithError500(
+  value: unknown,
+  name: string,
+  options: ErrorMetadataParams,
+): asserts value is {
+  status: 'failed';
+  error: RelayerApiError500;
+} {
+  assertIsRelayerResponseFailed(value, name, options);
+  assertIsRelayerApiError500(value.error, `${name}.error`, options);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// 503
+////////////////////////////////////////////////////////////////////////////////
+
+export function assertIsRelayerResponseFailedWithError503(
+  value: unknown,
+  name: string,
+  options: ErrorMetadataParams,
+): asserts value is {
+  status: 'failed';
+  error: RelayerApiError503;
+} {
+  assertIsRelayerResponseFailed(value, name, options);
+  assertIsRelayerApiError503(value.error, `${name}.error`, options);
+}

package/core/modules/relayer/module/guards/RelayerResponseQueued.ts

@@ -0,0 +1,51 @@
+import type { ErrorMetadataParams } from '../../../../base/errors/ErrorBase.js';
+import type { RelayerGetResponse202Queued, RelayerPostResponse202Queued } from '../../../../types/relayer-p.js';
+import { assertRecordNonNullableProperty } from '../../../../base/record.js';
+import { assertRecordStringProperty } from '../../../../base/string.js';
+
+/**
+ * Asserts that `value` matches the {@link RelayerPostResponseQueued} schema:
+ * ```json
+ * {
+ *   "status": "queued",
+ *   "requestId": "string",
+ *   "result": { "jobId": "string" }
+ * }
+ * ```
+ */
+export function assertIsRelayerPostResponse202Queued(
+  value: unknown,
+  name: string,
+  options: ErrorMetadataParams,
+): asserts value is RelayerPostResponse202Queued {
+  type T = RelayerPostResponse202Queued;
+  assertRecordStringProperty(value, 'status' satisfies keyof T, name, {
+    expectedValue: 'queued' satisfies T['status'],
+    ...options,
+  });
+  assertRecordStringProperty(value, 'requestId' satisfies keyof T, name, options);
+  assertRecordNonNullableProperty(value, 'result' satisfies keyof T, name, options);
+  assertRecordStringProperty(value.result, 'jobId', `${name}.result`, options);
+}
+
+/**
+ * Asserts that `value` matches the {@link RelayerGetResponse202Queued} schema:
+ * ```json
+ * {
+ *   "status": "queued",
+ *   "requestId": "string"
+ * }
+ * ```
+ */
+export function assertIsRelayerGetResponse202Queued(
+  value: unknown,
+  name: string,
+  options: ErrorMetadataParams,
+): asserts value is RelayerGetResponse202Queued {
+  type T = RelayerGetResponse202Queued;
+  assertRecordStringProperty(value, 'status' satisfies keyof T, name, {
+    expectedValue: 'queued' satisfies T['status'],
+    ...options,
+  });
+  assertRecordStringProperty(value, 'requestId' satisfies keyof T, name, options);
+}

package/core/modules/relayer/module/guards/RelayerUserDecryptSucceeded.ts

@@ -0,0 +1,77 @@
+import type { ErrorMetadataParams } from '../../../../base/errors/ErrorBase.js';
+import type { RelayerResult200UserDecrypt, RelayerUserDecryptSucceeded } from '../../../../types/relayer-p.js';
+import { assertRecordBytesHexNo0xProperty, assertRecordBytesHexProperty } from '../../../../base/bytes.js';
+import { assertRecordArrayProperty, assertRecordNonNullableProperty } from '../../../../base/record.js';
+import { assertRecordStringProperty } from '../../../../base/string.js';
+
+/**
+ * Asserts that `value` matches the {@link RelayerUserDecryptSucceeded} schema:
+ * ```json
+ * {
+ *   "status": "succeeded",
+ *   "requestId": "string",
+ *   "result": {
+ *     "result": [{
+ *       "payload": "hexNo0x...",
+ *       "signature": "hexNo0x...",
+ *       "extraData": "hex_or_hexNo0x_?..."
+ *     }]
+ *   }
+ * }
+ * ```
+ */
+export function assertIsRelayerUserDecryptSucceeded(
+  value: unknown,
+  name: string,
+  options: ErrorMetadataParams,
+): asserts value is RelayerUserDecryptSucceeded {
+  type T = RelayerUserDecryptSucceeded;
+  assertRecordStringProperty(value, 'status' satisfies keyof T, name, {
+    expectedValue: 'succeeded' satisfies T['status'],
+    ...options,
+  });
+  assertRecordStringProperty(value, 'requestId' satisfies keyof T, name, options);
+  assertRecordNonNullableProperty(value, 'result' satisfies keyof T, name, options);
+  _assertIsRelayerResult200UserDecrypt(value.result, `${name}.result`, options);
+}
+
+/**
+ * Asserts that `value` matches the {@link RelayerResult200UserDecrypt} schema:
+ * ```json
+ * {
+ *   "result": [{
+ *     "payload": "hexNo0x...",
+ *     "signature": "hexNo0x...",
+ *     "extraData": "hex_or_hexNo0x_?..."
+ *   }]
+ * }
+ * ```
+ */
+function _assertIsRelayerResult200UserDecrypt(
+  value: unknown,
+  name: string,
+  options: ErrorMetadataParams,
+): asserts value is RelayerResult200UserDecrypt {
+  type T = RelayerResult200UserDecrypt;
+  type ResultItem = T['result'][number];
+
+  assertRecordArrayProperty(value, 'result' satisfies keyof T, name, options);
+  for (let i = 0; i < value.result.length; ++i) {
+    assertRecordBytesHexNo0xProperty(
+      value.result[i],
+      'payload' satisfies keyof ResultItem,
+      `${name}.result[${i}]`,
+      options,
+    );
+    assertRecordBytesHexNo0xProperty(value.result[i], 'signature' satisfies keyof ResultItem, `${name}.result[${i}]`, {
+      ...options,
+      byteLength: 65,
+    });
+    assertRecordBytesHexProperty(
+      value.result[i],
+      'extraData' satisfies keyof ResultItem,
+      `${name}.result[${i}]`,
+      options,
+    );
+  }
+}

package/core/modules/relayer/module/guards/api-errors/RelayerApiError400NoDetails.ts

@@ -0,0 +1,65 @@
+import type { ErrorMetadataParams } from '../../../../../base/errors/ErrorBase.js';
+import type { RelayerApiError400NoDetails } from '../../../../../types/relayer-p.js';
+import { isRecordStringProperty } from '../../../../../base/string.js';
+import { assertRecordStringProperty } from '../../../../../base/string.js';
+import { InvalidPropertyError } from '../../../../../base/errors/InvalidPropertyError.js';
+
+/** @see {@link assertIsRelayerApiError400NoDetails} */
+export function isRelayerApiError400NoDetails(error: unknown): error is RelayerApiError400NoDetails {
+  type T = RelayerApiError400NoDetails;
+  if (!isRecordStringProperty(error, 'label' satisfies keyof T)) {
+    return false;
+  }
+  if (
+    !(
+      error.label === ('malformed_json' satisfies T['label']) ||
+      error.label === ('request_error' satisfies T['label']) ||
+      error.label === ('not_ready_for_decryption' satisfies T['label'])
+    )
+  ) {
+    return false;
+  }
+  return isRecordStringProperty(error, 'message' satisfies keyof T);
+}
+
+/**
+ * Asserts that a value matches the {@link RelayerApiError400NoDetails} schema:
+ * ```json
+ * {
+ *   "label": "malformed_json" | "request_error" | "not_ready_for_decryption",
+ *   "message": "string"
+ * }
+ * ```
+ */
+export function assertIsRelayerApiError400NoDetails(
+  value: unknown,
+  name: string,
+  options: ErrorMetadataParams,
+): asserts value is RelayerApiError400NoDetails {
+  type T = RelayerApiError400NoDetails;
+  assertRecordStringProperty(value, 'label' satisfies keyof T, name, options);
+  if (
+    !(
+      value.label === ('malformed_json' satisfies T['label']) ||
+      value.label === ('request_error' satisfies T['label']) ||
+      value.label === ('not_ready_for_decryption' satisfies T['label'])
+    )
+  ) {
+    throw new InvalidPropertyError(
+      {
+        subject: name,
+        property: 'label' satisfies keyof T,
+        expectedType: 'string',
+        expectedValue: [
+          'malformed_json' satisfies T['label'],
+          'request_error' satisfies T['label'],
+          'not_ready_for_decryption' satisfies T['label'],
+        ],
+        type: typeof value.label, // === "string"
+        value: value.label,
+      },
+      options,
+    );
+  }
+  assertRecordStringProperty(value, 'message' satisfies keyof T, name, options);
+}

package/core/modules/relayer/module/guards/api-errors/RelayerApiError400WithDetails.ts

@@ -0,0 +1,87 @@
+import type { ErrorMetadataParams } from '../../../../../base/errors/ErrorBase.js';
+import type { RelayerApiError400WithDetails } from '../../../../../types/relayer-p.js';
+import { InvalidPropertyError } from '../../../../../base/errors/InvalidPropertyError.js';
+import { assertRecordArrayProperty, isRecordArrayProperty } from '../../../../../base/record.js';
+import { assertRecordStringProperty, isRecordStringProperty } from '../../../../../base/string.js';
+
+/** @see {@link assertIsRelayerApiError400WithDetails} */
+export function isRelayerApiError400WithDetails(error: unknown): error is RelayerApiError400WithDetails {
+  type T = RelayerApiError400WithDetails;
+  type DetailItem = T['details'][number];
+  if (!isRecordStringProperty(error, 'label' satisfies keyof T)) {
+    return false;
+  }
+  if (
+    !(
+      error.label === ('missing_fields' satisfies T['label']) ||
+      error.label === ('validation_failed' satisfies T['label'])
+    )
+  ) {
+    return false;
+  }
+  if (!isRecordStringProperty(error, 'message' satisfies keyof T)) {
+    return false;
+  }
+  if (!isRecordArrayProperty(error, 'details' satisfies keyof T)) {
+    return false;
+  }
+  const arr = error.details;
+  for (let i = 0; i < arr.length; ++i) {
+    const detail = arr[i];
+    if (!isRecordStringProperty(detail, 'field' satisfies keyof DetailItem)) {
+      return false;
+    }
+    if (!isRecordStringProperty(detail, 'issue' satisfies keyof DetailItem)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+/**
+ * Asserts that a value matches the {@link RelayerApiError400WithDetails} schema:
+ * ```json
+ * {
+ *   "label": "missing_fields" | "validation_failed",
+ *   "message": "string",
+ *   "details": [
+ *     { "field": "string", "issue": "string" }
+ *   ]
+ * }
+ * ```
+ */
+export function assertIsRelayerApiError400WithDetails(
+  value: unknown,
+  name: string,
+  options: ErrorMetadataParams,
+): asserts value is RelayerApiError400WithDetails {
+  type T = RelayerApiError400WithDetails;
+  type DetailItem = T['details'][number];
+  assertRecordStringProperty(value, 'label' satisfies keyof T, name, options);
+  if (
+    !(
+      value.label === ('missing_fields' satisfies T['label']) ||
+      value.label === ('validation_failed' satisfies T['label'])
+    )
+  ) {
+    throw new InvalidPropertyError(
+      {
+        subject: name,
+        property: 'label' satisfies keyof T,
+        expectedType: 'string',
+        expectedValue: ['missing_fields' satisfies T['label'], 'validation_failed' satisfies T['label']],
+        type: typeof value.label,
+        value: value.label,
+      },
+      options,
+    );
+  }
+  assertRecordStringProperty(value, 'message' satisfies keyof T, name, options);
+  assertRecordArrayProperty(value, 'details' satisfies keyof T, name, options);
+  const arr = value.details;
+  for (let i = 0; i < arr.length; ++i) {
+    const detail = arr[i];
+    assertRecordStringProperty(detail, 'field' satisfies keyof DetailItem, `${name}.details[${i}]`, options);
+    assertRecordStringProperty(detail, 'issue' satisfies keyof DetailItem, `${name}.details[${i}]`, options);
+  }
+}

package/core/modules/relayer/module/guards/api-errors/RelayerApiError404.ts

@@ -0,0 +1,25 @@
+import type { ErrorMetadataParams } from '../../../../../base/errors/ErrorBase.js';
+import type { RelayerApiError404 } from '../../../../../types/relayer-p.js';
+import { assertRecordStringProperty } from '../../../../../base/string.js';
+
+/**
+ * Asserts that `value` matches the {@link RelayerApiError404} schema:
+ * ```json
+ * {
+ *   "label": "not_found",
+ *   "message": "string"
+ * }
+ * ```
+ */
+export function assertIsRelayerApiError404(
+  value: unknown,
+  name: string,
+  options: ErrorMetadataParams,
+): asserts value is RelayerApiError404 {
+  type T = RelayerApiError404;
+  assertRecordStringProperty(value, 'label' satisfies keyof T, name, {
+    expectedValue: 'not_found' satisfies T['label'],
+    ...options,
+  });
+  assertRecordStringProperty(value, 'message' satisfies keyof T, name, options);
+}

package/core/modules/relayer/module/guards/api-errors/RelayerApiError429.ts

@@ -0,0 +1,25 @@
+import type { ErrorMetadataParams } from '../../../../../base/errors/ErrorBase.js';
+import type { RelayerApiError429 } from '../../../../../types/relayer-p.js';
+import { assertRecordStringProperty } from '../../../../../base/string.js';
+
+/**
+ * Asserts that `error` matches the {@link RelayerApiError429} schema:
+ * ```json
+ * {
+ *   "label": "rate_limited" | "protocol_overload",
+ *   "message": "string"
+ * }
+ * ```
+ */
+export function assertIsRelayerApiError429(
+  error: unknown,
+  name: string,
+  options: ErrorMetadataParams,
+): asserts error is RelayerApiError429 {
+  type T = RelayerApiError429;
+  assertRecordStringProperty(error, 'label' satisfies keyof T, name, {
+    expectedValue: ['rate_limited' satisfies T['label'], 'protocol_overload' satisfies T['label']],
+    ...options,
+  });
+  assertRecordStringProperty(error, 'message' satisfies keyof T, name, options);
+}

package/core/modules/relayer/module/guards/api-errors/RelayerApiError500.ts

@@ -0,0 +1,25 @@
+import type { ErrorMetadataParams } from '../../../../../base/errors/ErrorBase.js';
+import type { RelayerApiError500 } from '../../../../../types/relayer-p.js';
+import { assertRecordStringProperty } from '../../../../../base/string.js';
+
+/**
+ * Asserts that `value` matches the {@link RelayerApiError500} schema:
+ * ```json
+ * {
+ *   "label": "internal_server_error",
+ *   "message": "string"
+ * }
+ * ```
+ */
+export function assertIsRelayerApiError500(
+  value: unknown,
+  name: string,
+  options: ErrorMetadataParams,
+): asserts value is RelayerApiError500 {
+  type T = RelayerApiError500;
+  assertRecordStringProperty(value, 'label' satisfies keyof T, name, {
+    expectedValue: 'internal_server_error' satisfies T['label'],
+    ...options,
+  });
+  assertRecordStringProperty(value, 'message' satisfies keyof T, name, options);
+}

package/core/modules/relayer/module/guards/api-errors/RelayerApiError503.ts

@@ -0,0 +1,30 @@
+import type { ErrorMetadataParams } from '../../../../../base/errors/ErrorBase.js';
+import type { RelayerApiError503 } from '../../../../../types/relayer-p.js';
+import { assertRecordStringProperty } from '../../../../../base/string.js';
+
+/**
+ * Asserts that `value` matches the {@link RelayerApiError503} schema:
+ * ```json
+ * {
+ *   "label": "protocol_paused" | "gateway_not_reachable" | "readiness_check_timed_out" | "response_timed_out",
+ *   "message": "string"
+ * }
+ * ```
+ */
+export function assertIsRelayerApiError503(
+  value: unknown,
+  name: string,
+  options: ErrorMetadataParams,
+): asserts value is RelayerApiError503 {
+  type T = RelayerApiError503;
+  assertRecordStringProperty(value, 'label' satisfies keyof T, name, {
+    expectedValue: [
+      'protocol_paused' satisfies T['label'],
+      'gateway_not_reachable' satisfies T['label'],
+      'readiness_check_timed_out' satisfies T['label'],
+      'response_timed_out' satisfies T['label'],
+    ],
+    ...options,
+  });
+  assertRecordStringProperty(value, 'message' satisfies keyof T, name, options);
+}

package/core/modules/relayer/module/index.ts

@@ -0,0 +1,24 @@
+import type { RelayerModuleFactory } from '../types.js';
+import { fetchCoprocessorSignatures } from './fetchCoprocessorSignatures.js';
+import { fetchDelegatedUserDecrypt } from './fetchDelegatedUserDecrypt.js';
+import { fetchPublicDecrypt } from './fetchPublicDecrypt.js';
+import { fetchFheEncryptionKeyBytes } from './fetchFheEncryptionKeyBytes.js';
+import { fetchFheEncryptionKeySource } from './fetchFheEncryptionKeySource.js';
+import { fetchUserDecrypt } from './fetchUserDecrypt.js';
+
+////////////////////////////////////////////////////////////////////////////////
+// relayerModule
+////////////////////////////////////////////////////////////////////////////////
+
+export const relayerModule: RelayerModuleFactory = () => {
+  return Object.freeze({
+    relayer: Object.freeze({
+      fetchFheEncryptionKeySource,
+      fetchFheEncryptionKeyBytes,
+      fetchCoprocessorSignatures,
+      fetchPublicDecrypt,
+      fetchUserDecrypt,
+      fetchDelegatedUserDecrypt,
+    }),
+  });
+};