@reclaimprotocol/attestor-core 5.0.1-beta.7 → 5.0.1

package/lib/server/handlers/createClaimOnChain.js

@@ -1,32 +0,0 @@
-import { getContracts } from "../../avs/utils/contracts.js";
-import { createNewClaimRequestOnChain } from "../../avs/utils/tasks.js";
-import { getEnvVariable } from "../../utils/env.js";
-import { AttestorError, ethersStructToPlainObject } from "../../utils/index.js";
-const ACCEPT_CLAIM_PAYMENT_REQUESTS = getEnvVariable("ACCEPT_CLAIM_PAYMENT_REQUESTS") === "1";
-const createClaimOnChain = async ({ chainId: chainIdNum, jsonCreateClaimRequest, requestSignature }) => {
-  if (!ACCEPT_CLAIM_PAYMENT_REQUESTS) {
-    throw new AttestorError(
-      "ERROR_PAYMENT_REFUSED",
-      "Payment requests are not accepted at this time"
-    );
-  }
-  const chainId = chainIdNum.toString();
-  const { wallet } = getContracts(chainId.toString());
-  const request = JSON.parse(jsonCreateClaimRequest);
-  const { task, tx } = await createNewClaimRequestOnChain({
-    request,
-    owner: request.owner,
-    payer: wallet,
-    chainId,
-    requestSignature
-  });
-  const plainTask = ethersStructToPlainObject(task);
-  return {
-    txHash: tx?.hash ?? "",
-    taskIndex: Number(task.taskIndex),
-    jsonTask: JSON.stringify(plainTask)
-  };
-};
-export {
-  createClaimOnChain
-};

package/lib/server/handlers/createTaskOnMechain.js

@@ -1,57 +0,0 @@
-import { Contract, JsonRpcProvider, randomBytes, Wallet } from "ethers";
-import { governanceABI } from "../../mechain/abis/governanceABI.js";
-import { taskABI } from "../../mechain/abis/taskABI.js";
-import { GOVERNANCE_CONTRACT_ADDRESS, RPC_URL, TASK_CONTRACT_ADDRESS } from "../../mechain/constants/index.js";
-import { getEnvVariable } from "../../utils/env.js";
-const createTaskOnMechain = async ({
-  timestamp
-}) => {
-  const { taskContract } = await getContracts();
-  const seed = randomBytes(32);
-  const result = await taskContract.createNewTaskRequest.staticCall(
-    seed,
-    timestamp
-  );
-  const taskId = result[0];
-  const requiredAttestors = await taskContract.requiredAttestors();
-  const hosts = [];
-  for (let i = 0; i < requiredAttestors; i++) {
-    hosts.push(result[1][i].host);
-  }
-  const tx = await taskContract.createNewTaskRequest(seed, timestamp);
-  await tx.wait();
-  return {
-    taskId,
-    requiredAttestors,
-    hosts
-  };
-};
-async function getContracts() {
-  const privateKey = getEnvVariable("MECHAIN_PRIVATE_KEY");
-  const taskContractAddress = getEnvVariable("TASK_CONTRACT_ADDRESS") || TASK_CONTRACT_ADDRESS;
-  const governanceContractAddress = getEnvVariable("GOVERNANCE_CONTRACT_ADDRESS") || GOVERNANCE_CONTRACT_ADDRESS;
-  if (!privateKey) {
-    throw new Error("MECHAIN_PRIVATE_KEY environment variable is not set");
-  }
-  try {
-    const provider = new JsonRpcProvider(RPC_URL);
-    await provider.getNetwork();
-    const signer = new Wallet(privateKey, provider);
-    const taskContract = new Contract(
-      taskContractAddress,
-      taskABI,
-      signer
-    );
-    const governanceContract = new Contract(
-      governanceContractAddress,
-      governanceABI,
-      signer
-    );
-    return { taskContract, governanceContract };
-  } catch (error) {
-    throw new Error(`Failed to initialize contracts: ${error.message || error}`);
-  }
-}
-export {
-  createTaskOnMechain
-};

package/lib/server/handlers/createTunnel.js

@@ -1,98 +0,0 @@
-import { makeTcpTunnel } from "../../server/tunnels/make-tcp-tunnel.js";
-import { getApm } from "../../server/utils/apm.js";
-import { resolveHostnames } from "../../server/utils/dns.js";
-import { AttestorError } from "../../utils/index.js";
-const createTunnel = async ({ id, ...opts }, { tx, logger, client }) => {
-  if (client.tunnels[id]) {
-    throw AttestorError.badRequest(`Tunnel "${id}" already exists`);
-  }
-  const allowedHosts = client.metadata?.auth?.data?.hostWhitelist;
-  if (allowedHosts?.length && !allowedHosts.includes(opts.host)) {
-    throw AttestorError.badRequest(
-      `Host "${opts.host}" not allowed by auth request`
-    );
-  }
-  let cancelBgp;
-  const apm = getApm();
-  const sessionTx = apm?.startTransaction("tunnelConnection", { childOf: tx });
-  sessionTx?.setLabel("tunnelId", id.toString());
-  sessionTx?.setLabel("hostPort", `${opts.host}:${opts.port}`);
-  sessionTx?.setLabel("geoLocation", opts.geoLocation);
-  sessionTx?.setLabel("proxySessionId", opts.proxySessionId);
-  try {
-    const tunnel = await makeTcpTunnel({
-      ...opts,
-      logger,
-      onMessage(message) {
-        if (!client.isOpen) {
-          logger.warn("client is closed, dropping message");
-          return;
-        }
-        return client.sendMessage({ tunnelMessage: { tunnelId: id, message } });
-      },
-      onClose(err) {
-        cancelBgp?.();
-        if (err) {
-          apm?.captureError(err, { parent: sessionTx });
-          sessionTx?.setOutcome("failure");
-        } else {
-          sessionTx?.setOutcome("success");
-        }
-        sessionTx?.end();
-        if (!client.isOpen) {
-          return;
-        }
-        client.sendMessage({
-          tunnelDisconnectEvent: {
-            tunnelId: id,
-            error: err ? AttestorError.fromError(err).toProto() : void 0
-          }
-        }).catch((err2) => {
-          logger.error(
-            { err: err2 },
-            "failed to send tunnel disconnect event"
-          );
-        });
-      }
-    });
-    try {
-      await checkForBgp(tunnel);
-    } catch (err) {
-      logger.warn(
-        { err, host: opts.host },
-        "failed to start BGP overlap check"
-      );
-    }
-    client.tunnels[id] = tunnel;
-    return {};
-  } catch (err) {
-    apm?.captureError(err, { parent: sessionTx });
-    sessionTx?.setOutcome("failure");
-    sessionTx?.end();
-    cancelBgp?.();
-    throw err;
-  }
-  async function checkForBgp(tunnel) {
-    if (!client.bgpListener) {
-      return;
-    }
-    const ips = await resolveHostnames(opts.host);
-    cancelBgp = client.bgpListener.onOverlap(ips, (info) => {
-      logger.warn(
-        { info, host: opts.host },
-        "BGP announcement overlap detected"
-      );
-      sessionTx?.addLabels({ bgpOverlap: true, ...info });
-      void tunnel?.close(
-        new AttestorError(
-          "ERROR_BGP_ANNOUNCEMENT_OVERLAP",
-          `BGP announcement overlap detected for ${opts.host}`
-        )
-      );
-    });
-    logger.debug({ ips }, "checking for BGP overlap");
-  }
-};
-export {
-  createTunnel
-};

package/lib/server/handlers/disconnectTunnel.js

@@ -1,8 +0,0 @@
-const disconnectTunnel = async ({ id }, { client }) => {
-  const tunnel = client.getTunnel(id);
-  await tunnel.close();
-  return {};
-};
-export {
-  disconnectTunnel
-};

package/lib/server/handlers/fetchCertificateBytes.js

@@ -1,57 +0,0 @@
-import { concatenateUint8Arrays, loadX509FromPem } from "@reclaimprotocol/tls";
-import { CERT_ALLOWED_MIMETYPES, MAX_CERT_SIZE_BYTES } from "../../config/index.js";
-import { AttestorError } from "../../utils/error.js";
-const fetchCertificateBytes = async ({ url }) => {
-  const res = await fetch(url, {
-    redirect: "follow",
-    signal: AbortSignal.timeout(1e4)
-  });
-  if (!res.ok) {
-    res.body?.cancel("Not ok");
-    throw new AttestorError(
-      "ERROR_CERTIFICATE_FETCH_FAILED",
-      `Failed to fetch certificate from URL: ${url}, status: ${res.status}`
-    );
-  }
-  const contentType = res.headers.get("content-type");
-  if (!contentType || !CERT_ALLOWED_MIMETYPES.includes(contentType)) {
-    res.body?.cancel("Mismatch");
-    throw new AttestorError(
-      "ERROR_CERTIFICATE_FETCH_FAILED",
-      `Invalid content-type when fetching certificate from URL: ${url}, content-type: ${contentType}`
-    );
-  }
-  if (!res.body) {
-    throw new AttestorError(
-      "ERROR_CERTIFICATE_FETCH_FAILED",
-      `No body in response when fetching certificate from URL: ${url}`
-    );
-  }
-  let total = 0;
-  const byteArr = [];
-  for await (const chunk of res.body) {
-    total += chunk.length;
-    if (total > MAX_CERT_SIZE_BYTES) {
-      res.body.cancel("Too many bytes");
-      throw new AttestorError(
-        "ERROR_CERTIFICATE_FETCH_FAILED",
-        `Certificate size exceeds maximum limit of ${MAX_CERT_SIZE_BYTES}b`
-      );
-    }
-    byteArr.push(chunk);
-  }
-  const bytes = concatenateUint8Arrays(byteArr);
-  try {
-    const cert = loadX509FromPem(bytes);
-    TLS_INTERMEDIATE_CA_CACHE[url] = cert;
-  } catch (err) {
-    throw new AttestorError(
-      "ERROR_CERTIFICATE_FETCH_FAILED",
-      `Failed to parse certificate, error: ${err.message}`
-    );
-  }
-  return { bytes: concatenateUint8Arrays(byteArr) };
-};
-export {
-  fetchCertificateBytes
-};

package/lib/server/handlers/index.js

@@ -1,25 +0,0 @@
-import { claimTeeBundle } from "../../server/handlers/claimTeeBundle.js";
-import { claimTunnel } from "../../server/handlers/claimTunnel.js";
-import { completeClaimOnChain } from "../../server/handlers/completeClaimOnChain.js";
-import { createClaimOnChain } from "../../server/handlers/createClaimOnChain.js";
-import { createTaskOnMechain } from "../../server/handlers/createTaskOnMechain.js";
-import { createTunnel } from "../../server/handlers/createTunnel.js";
-import { disconnectTunnel } from "../../server/handlers/disconnectTunnel.js";
-import { fetchCertificateBytes } from "../../server/handlers/fetchCertificateBytes.js";
-import { init } from "../../server/handlers/init.js";
-import { toprf } from "../../server/handlers/toprf.js";
-const HANDLERS = {
-  createTunnel,
-  disconnectTunnel,
-  claimTunnel,
-  claimTeeBundle,
-  init,
-  createClaimOnChain,
-  completeClaimOnChain,
-  toprf,
-  createTaskOnMechain,
-  fetchCertificateBytes
-};
-export {
-  HANDLERS
-};

package/lib/server/handlers/init.js

@@ -1,33 +0,0 @@
-import { getBytes } from "ethers";
-import { getAttestorAddress } from "../../server/utils/generics.js";
-import { assertValidAuthRequest } from "../../utils/auth.js";
-import { getEnvVariable } from "../../utils/env.js";
-import { AttestorError } from "../../utils/index.js";
-import { SIGNATURES } from "../../utils/signatures/index.js";
-const TOPRF_PUBLIC_KEY = getEnvVariable("TOPRF_PUBLIC_KEY");
-const init = async (initRequest, { client }) => {
-  if (client.isInitialised) {
-    throw AttestorError.badRequest("Client already initialised");
-  }
-  if (!SIGNATURES[initRequest.signatureType]) {
-    throw AttestorError.badRequest("Unsupported signature type");
-  }
-  if (initRequest.clientVersion <= 0) {
-    throw AttestorError.badRequest("Unsupported client version");
-  }
-  await assertValidAuthRequest(initRequest.auth, initRequest.signatureType);
-  if (initRequest.auth?.data) {
-    client.logger = client.logger.child({
-      userId: initRequest.auth.data.id
-    });
-  }
-  client.metadata = initRequest;
-  client.isInitialised = true;
-  return {
-    toprfPublicKey: TOPRF_PUBLIC_KEY ? getBytes(TOPRF_PUBLIC_KEY) : new Uint8Array(),
-    attestorAddress: getAttestorAddress(initRequest.signatureType)
-  };
-};
-export {
-  init
-};

package/lib/server/handlers/toprf.js

@@ -1,19 +0,0 @@
-import { getBytes } from "ethers";
-import { getEnvVariable } from "../../utils/env.js";
-import { getEngineString, makeDefaultOPRFOperator } from "../../utils/index.js";
-const toprf = async ({ maskedData, engine }, { logger }) => {
-  const PRIVATE_KEY_STR = getEnvVariable("TOPRF_SHARE_PRIVATE_KEY");
-  const PUBLIC_KEY_STR = getEnvVariable("TOPRF_SHARE_PUBLIC_KEY");
-  if (!PRIVATE_KEY_STR || !PUBLIC_KEY_STR) {
-    throw new Error("private/public keys not set. Cannot execute OPRF");
-  }
-  const PRIVATE_KEY = getBytes(PRIVATE_KEY_STR);
-  const PUBLIC_KEY = getBytes(PUBLIC_KEY_STR);
-  const engineStr = getEngineString(engine);
-  const operator = makeDefaultOPRFOperator("chacha20", engineStr, logger);
-  const res = await operator.evaluateOPRF(PRIVATE_KEY, maskedData);
-  return { ...res, publicKeyShare: PUBLIC_KEY };
-};
-export {
-  toprf
-};

package/lib/server/index.js

@@ -1,4 +0,0 @@
-export * from "./utils/config-env.js";
-export * from "./create-server.js";
-export * from "./tunnels/make-tcp-tunnel.js";
-export * from "./utils/assert-valid-claim-request.js";

package/lib/server/socket.js

@@ -1,112 +0,0 @@
-import { promisify } from "util";
-import { handleMessage } from "../client/utils/message-handler.js";
-import { DEFAULT_RPC_TIMEOUT_MS } from "../config/index.js";
-import { HANDLERS } from "../server/handlers/index.js";
-import { getApm } from "../server/utils/apm.js";
-import { getInitialMessagesFromQuery } from "../server/utils/generics.js";
-import { AttestorError, generateSessionId } from "../utils/index.js";
-import { AttestorSocket } from "../utils/socket-base.js";
-class AttestorServerSocket extends AttestorSocket {
-  tunnels = {};
-  sessionId;
-  bgpListener;
-  constructor(socket, sessionId, bgpListener, logger) {
-    super(socket, {}, logger);
-    this.sessionId = sessionId;
-    this.bgpListener = bgpListener;
-    this.addEventListener("rpc-request", handleRpcRequest.bind(this));
-    this.addEventListener("tunnel-message", handleTunnelMessage.bind(this));
-    this.addEventListener("connection-terminated", () => {
-      for (const tunnelId in this.tunnels) {
-        const tunnel = this.tunnels[tunnelId];
-        void tunnel.close(new Error("WS session terminated"));
-      }
-    });
-  }
-  getTunnel(tunnelId) {
-    const tunnel = this.tunnels[tunnelId];
-    if (!tunnel) {
-      throw new AttestorError(
-        "ERROR_NOT_FOUND",
-        `Tunnel "${tunnelId}" not found`
-      );
-    }
-    return tunnel;
-  }
-  removeTunnel(tunnelId) {
-    delete this.tunnels[tunnelId];
-  }
-  static async acceptConnection(socket, { req, logger, bgpListener }) {
-    const bindSend = socket.send.bind(socket);
-    socket.send = promisify(bindSend);
-    const sessionId = generateSessionId();
-    logger = logger.child({ sessionId });
-    const client = new AttestorServerSocket(
-      socket,
-      sessionId,
-      bgpListener,
-      logger
-    );
-    try {
-      const initMsgs = getInitialMessagesFromQuery(req);
-      logger.trace(
-        { initMsgs: initMsgs.length },
-        "new connection, validating..."
-      );
-      for (const msg of initMsgs) {
-        await handleMessage.call(client, msg);
-      }
-      logger.debug("connection accepted");
-    } catch (err) {
-      logger.error({ err }, "error in new connection");
-      if (client.isOpen) {
-        await client.terminateConnection(
-          err instanceof AttestorError ? err : AttestorError.badRequest(err.message)
-        );
-      }
-      return;
-    }
-    return client;
-  }
-}
-async function handleTunnelMessage({ data: { tunnelId, message } }) {
-  try {
-    const tunnel = this.getTunnel(tunnelId);
-    await tunnel.write(message);
-  } catch (err) {
-    this.logger?.error({ err, tunnelId }, "error writing to tunnel");
-  }
-}
-async function handleRpcRequest({ data: { data, requestId, respond, type } }) {
-  const logger = this.logger.child({ rpc: type, requestId });
-  const apm = getApm();
-  const tx = apm?.startTransaction(type);
-  tx?.setLabel("requestId", requestId);
-  tx?.setLabel("sessionId", this.sessionId.toString());
-  const userId = this.metadata.auth?.data?.id;
-  if (userId) {
-    tx?.setLabel("authUserId", userId);
-  }
-  const timeout = setTimeout(() => {
-    logger.warn({ type, requestId }, "RPC took too long to respond");
-  }, DEFAULT_RPC_TIMEOUT_MS);
-  try {
-    logger.debug({ data }, "handling RPC request");
-    const handler = HANDLERS[type];
-    const res = await handler(data, { client: this, logger, tx });
-    respond(res);
-    logger.debug({ res }, "handled RPC request");
-    tx?.setOutcome("success");
-  } catch (err) {
-    logger.error({ err }, "error in RPC request");
-    respond(AttestorError.fromError(err));
-    tx?.setOutcome("failure");
-    apm?.captureError(err, { parent: tx });
-  } finally {
-    clearTimeout(timeout);
-    tx?.end();
-  }
-}
-export {
-  AttestorServerSocket
-};

package/lib/server/tunnels/make-tcp-tunnel.js

@@ -1,202 +0,0 @@
-import { HttpsProxyAgent } from "https-proxy-agent";
-import { Socket } from "net";
-import { CONNECTION_TIMEOUT_MS } from "../../config/index.js";
-import { resolveHostnames } from "../../server/utils/dns.js";
-import { isValidCountryCode } from "../../server/utils/iso.js";
-import { isValidProxySessionId } from "../../utils/generics.js";
-import { getEnvVariable } from "../../utils/env.js";
-import { AttestorError } from "../../utils/index.js";
-const HTTPS_PROXY_URL = getEnvVariable("HTTPS_PROXY_URL");
-const makeTcpTunnel = async ({
-  onClose,
-  onMessage,
-  logger,
-  ...opts
-}) => {
-  const transcript = [];
-  const socket = await connectTcp({ ...opts, logger });
-  let closed = false;
-  socket.on("data", (message) => {
-    if (closed) {
-      logger.warn("socket is closed, dropping message");
-      return;
-    }
-    onMessage?.(message);
-    transcript.push({ sender: "server", message });
-  });
-  socket.once("close", () => onSocketClose(void 0));
-  return {
-    socket,
-    transcript,
-    createRequest: opts,
-    async write(data) {
-      transcript.push({ sender: "client", message: data });
-      await new Promise((resolve, reject) => {
-        socket.write(data, (err) => {
-          if (err) {
-            reject(err);
-          } else {
-            resolve();
-          }
-        });
-      });
-    },
-    close(err) {
-      if (closed) {
-        return;
-      }
-      socket.destroy(err);
-    }
-  };
-  function onSocketClose(err) {
-    if (closed) {
-      return;
-    }
-    logger.debug({ err }, "closing socket");
-    closed = true;
-    onClose?.(err);
-    onClose = void 0;
-  }
-};
-async function connectTcp({ host, port, geoLocation, proxySessionId, logger }) {
-  let connectTimeout;
-  let socket;
-  try {
-    await new Promise(async (resolve, reject) => {
-      try {
-        connectTimeout = setTimeout(
-          () => reject(
-            new AttestorError(
-              "ERROR_NETWORK_ERROR",
-              "Server connection timed out"
-            )
-          ),
-          CONNECTION_TIMEOUT_MS
-        );
-        socket = await getSocket({
-          host,
-          port,
-          geoLocation,
-          proxySessionId,
-          logger
-        });
-        socket.once("connect", resolve);
-        socket.once("error", reject);
-        socket.once("end", () => reject(
-          new AttestorError(
-            "ERROR_NETWORK_ERROR",
-            "connection closed"
-          )
-        ));
-      } catch (err) {
-        reject(err);
-      }
-    });
-    logger.debug({ addr: `${host}:${port}` }, "connected");
-    return socket;
-  } catch (err) {
-    socket?.end();
-    throw err;
-  } finally {
-    clearTimeout(connectTimeout);
-  }
-}
-async function getSocket(opts) {
-  const { logger } = opts;
-  try {
-    return await _getSocket(opts);
-  } catch (err) {
-    if (!(err instanceof AttestorError) || err.data?.code !== 403) {
-      throw err;
-    }
-    const addrs = await resolveHostnames(opts.host);
-    logger.info(
-      { addrs, host: opts.host },
-      "failed to connect due to restricted IP, trying via raw addr"
-    );
-    for (const addr of addrs) {
-      try {
-        return await _getSocket({ ...opts, host: addr });
-      } catch (err2) {
-        logger.error(
-          { addr, err: err2 },
-          "failed to connect to host"
-        );
-      }
-    }
-    throw err;
-  }
-}
-async function _getSocket({
-  host,
-  port,
-  geoLocation,
-  proxySessionId,
-  logger
-}) {
-  const socket = new Socket();
-  if ((proxySessionId || geoLocation) && !HTTPS_PROXY_URL) {
-    logger.warn(
-      { geoLocation, proxySessionId },
-      "geoLocation or proxySessionId provided but no proxy URL found"
-    );
-    geoLocation = "";
-    proxySessionId = "";
-  }
-  if (!geoLocation && !proxySessionId) {
-    socket.connect({ host, port });
-    return socket;
-  }
-  if (!isValidCountryCode(geoLocation)) {
-    throw AttestorError.badRequest(
-      `Geolocation "${geoLocation}" is invalid. Must be 2 letter ISO country code`,
-      { geoLocation }
-    );
-  }
-  if (proxySessionId && !isValidProxySessionId(proxySessionId)) {
-    throw AttestorError.badRequest(
-      `proxySessionId "${proxySessionId}" is invalid. Must be a lowercase alphanumeric string of length 8-14 characters. eg. "mystring12345", "something1234".`,
-      { proxySessionId }
-    );
-  }
-  const agentUrl = HTTPS_PROXY_URL.replace(
-    "{{geoLocation}}",
-    geoLocation?.toLowerCase() || ""
-  ).replace(
-    "{{proxySessionId}}",
-    proxySessionId ? `-session-${proxySessionId}` : ""
-  );
-  const agent = new HttpsProxyAgent(agentUrl);
-  const waitForProxyRes = new Promise((resolve) => {
-    socket.once("proxyConnect", resolve);
-  });
-  const proxySocket = await agent.connect(
-    // ignore, because https-proxy-agent
-    // expects an http request object
-    // @ts-ignore
-    socket,
-    { host, port, timeout: CONNECTION_TIMEOUT_MS }
-  );
-  const res = await waitForProxyRes;
-  if (res.statusCode !== 200) {
-    logger.error(
-      { geoLocation, proxySessionId, res },
-      "Proxy geo location or session id failed"
-    );
-    throw new AttestorError(
-      "ERROR_PROXY_ERROR",
-      `Proxy via ${geoLocation ? `geo location "${geoLocation}"` : ""}${geoLocation && proxySessionId ? ", or " : ""}${proxySessionId ? `session id "${proxySessionId}"` : ""} failed with status code: ${res.statusCode}, message: ${res.statusText}`,
-      {
-        code: res.statusCode,
-        message: res.statusText
-      }
-    );
-  }
-  process.nextTick(() => {
-    proxySocket.emit("connect");
-  });
-  return proxySocket;
-}
-export {
-  makeTcpTunnel
-};

package/lib/server/utils/apm.js

@@ -1,29 +0,0 @@
-import ElasticAPM from "elastic-apm-node";
-import { getEnvVariable } from "../../utils/env.js";
-import { logger } from "../../utils/logger.js";
-let apm;
-function getApm() {
-  if (!getEnvVariable("ELASTIC_APM_SERVER_URL") || !getEnvVariable("ELASTIC_APM_SECRET_TOKEN")) {
-    logger.info(
-      "ELASTIC_APM_SERVER_URL or ELASTIC_APM_SECRET_TOKEN not found in env, APM agent not initialised"
-    );
-    return void 0;
-  }
-  if (!apm) {
-    const sampleRate = +(getEnvVariable("ELASTIC_APM_SAMPLE_RATE") || "0.1");
-    apm = ElasticAPM.start({
-      serviceName: "reclaim_attestor",
-      serviceVersion: "4.0.0",
-      transactionSampleRate: sampleRate,
-      instrumentIncomingHTTPRequests: true,
-      usePathAsTransactionName: true,
-      instrument: true,
-      captureHeaders: true
-    });
-    logger.info("initialised APM agent");
-  }
-  return apm;
-}
-export {
-  getApm
-};