@reclaimprotocol/attestor-core 5.0.1-beta.2 → 5.0.1-beta.22

package/lib/client/tunnels/make-rpc-tcp-tunnel.js

@@ -1,53 +1,51 @@
 import { AttestorError } from "../../utils/index.js";
-const makeRpcTcpTunnel = ({
-  tunnelId,
-  client,
-  onClose,
-  onMessage
-}) => {
-  let closed = false;
-  client.addEventListener("tunnel-message", onMessageListener);
-  client.addEventListener("tunnel-disconnect-event", onDisconnectListener);
-  client.addEventListener("connection-terminated", onConnectionTerminatedListener);
-  return {
-    async write(message) {
-      await client.sendMessage({ tunnelMessage: { tunnelId, message } });
-    },
-    async close(err) {
-      if (closed) {
-        return;
-      }
-      onErrorRecv(err);
-      await client.rpc("disconnectTunnel", { id: tunnelId });
+/**
+ * Makes a tunnel communication wrapper for a TCP tunnel.
+ *
+ * It listens for messages and disconnect events from the server,
+ * and appropriately calls the `onMessage` and `onClose` callbacks.
+ */
+export const makeRpcTcpTunnel = ({ tunnelId, client, onClose, onMessage, }) => {
+    let closed = false;
+    client.addEventListener('tunnel-message', onMessageListener);
+    client.addEventListener('tunnel-disconnect-event', onDisconnectListener);
+    client.addEventListener('connection-terminated', onConnectionTerminatedListener);
+    return {
+        async write(message) {
+            await client.sendMessage({ tunnelMessage: { tunnelId, message } });
+        },
+        async close(err) {
+            if (closed) {
+                return;
+            }
+            onErrorRecv(err);
+            await client.rpc('disconnectTunnel', { id: tunnelId });
+        }
+    };
+    function onMessageListener({ data }) {
+        if (data.tunnelId !== tunnelId) {
+            return;
+        }
+        onMessage?.(data.message);
     }
-  };
-  function onMessageListener({ data }) {
-    if (data.tunnelId !== tunnelId) {
-      return;
+    function onDisconnectListener({ data }) {
+        if (data.tunnelId !== tunnelId) {
+            return;
+        }
+        onErrorRecv(data.error?.code
+            ? AttestorError.fromProto(data.error)
+            : undefined);
     }
-    onMessage?.(data.message);
-  }
-  function onDisconnectListener({ data }) {
-    if (data.tunnelId !== tunnelId) {
-      return;
+    function onConnectionTerminatedListener({ data }) {
+        onErrorRecv(data);
+    }
+    function onErrorRecv(err) {
+        client.logger?.debug({ tunnelId, err }, 'TCP tunnel closed');
+        client.removeEventListener('tunnel-message', onMessageListener);
+        client.removeEventListener('tunnel-disconnect-event', onDisconnectListener);
+        client.removeEventListener('connection-terminated', onConnectionTerminatedListener);
+        onClose?.(err);
+        onClose = undefined;
+        closed = true;
     }
-    onErrorRecv(
-      data.error?.code ? AttestorError.fromProto(data.error) : void 0
-    );
-  }
-  function onConnectionTerminatedListener({ data }) {
-    onErrorRecv(data);
-  }
-  function onErrorRecv(err) {
-    client.logger?.debug({ tunnelId, err }, "TCP tunnel closed");
-    client.removeEventListener("tunnel-message", onMessageListener);
-    client.removeEventListener("tunnel-disconnect-event", onDisconnectListener);
-    client.removeEventListener("connection-terminated", onConnectionTerminatedListener);
-    onClose?.(err);
-    onClose = void 0;
-    closed = true;
-  }
-};
-export {
-  makeRpcTcpTunnel
 };

package/lib/client/tunnels/make-rpc-tls-tunnel.js

@@ -1,127 +1,131 @@
-import { concatenateUint8Arrays, makeTLSClient } from "@reclaimprotocol/tls";
-import { makeRpcTcpTunnel } from "../../client/tunnels/make-rpc-tcp-tunnel.js";
+import { concatenateUint8Arrays, makeTLSClient } from '@reclaimprotocol/tls';
+import { makeRpcTcpTunnel } from "./make-rpc-tcp-tunnel.js";
 import { DEFAULT_HTTPS_PORT } from "../../config/index.js";
 import { generateRpcMessageId, generateTunnelId } from "../../utils/index.js";
-const makeRpcTlsTunnel = async ({
-  onMessage,
-  onClose,
-  tlsOpts,
-  request,
-  connect,
-  logger
-}) => {
-  const transcript = [];
-  const tunnelId = request.id || generateTunnelId();
-  let tunnel;
-  let client;
-  let handshakeResolve;
-  let handshakeReject;
-  const waitForHandshake = new Promise((resolve, reject) => {
-    handshakeResolve = resolve;
-    handshakeReject = reject;
-  });
-  const tls = makeTLSClient({
-    host: request.host,
-    ...tlsOpts,
-    logger,
-    onHandshake() {
-      handshakeResolve?.();
-    },
-    onApplicationData(plaintext) {
-      return onMessage?.(plaintext);
-    },
-    onTlsEnd: onConnectionClose,
-    async write(packet, ctx) {
-      const message = concatenateUint8Arrays([
-        packet.header,
-        packet.content
-      ]);
-      transcript.push({
-        sender: "client",
-        message: { ...ctx, data: message }
-      });
-      if (!tunnel) {
-        const createTunnelReqId = generateRpcMessageId();
-        client = connect([
-          {
-            id: createTunnelReqId,
-            createTunnelRequest: {
-              host: request.host || "",
-              port: request.port || DEFAULT_HTTPS_PORT,
-              geoLocation: request.geoLocation || "",
-              proxySessionId: request.proxySessionId || "",
-              id: tunnelId
+/**
+ * Makes a TLS tunnel that connects to the server via RPC protocol
+ */
+export const makeRpcTlsTunnel = async ({ onMessage, onClose, tlsOpts, request, connect, logger }) => {
+    const transcript = [];
+    const tunnelId = request.id || generateTunnelId();
+    let tunnel;
+    let client;
+    let handshakeResolve;
+    let handshakeReject;
+    const waitForHandshake = new Promise((resolve, reject) => {
+        handshakeResolve = resolve;
+        handshakeReject = reject;
+    });
+    const tls = makeTLSClient({
+        host: request.host,
+        ...tlsOpts,
+        logger,
+        onHandshake() {
+            handshakeResolve?.();
+        },
+        onApplicationData(plaintext) {
+            return onMessage?.(plaintext);
+        },
+        onTlsEnd: onConnectionClose,
+        async write(packet, ctx) {
+            const message = concatenateUint8Arrays([
+                packet.header,
+                packet.content
+            ]);
+            transcript.push({
+                sender: 'client',
+                message: { ...ctx, data: message }
+            });
+            if (!tunnel) {
+                // sends the packet as the initial message
+                // to the plaintext tunnel. Prevents another
+                // round trip to the server as we send the packet
+                // in the same message as the tunnel creation.
+                const createTunnelReqId = generateRpcMessageId();
+                client = connect([
+                    {
+                        id: createTunnelReqId,
+                        createTunnelRequest: {
+                            host: request.host || '',
+                            port: request.port || DEFAULT_HTTPS_PORT,
+                            geoLocation: request.geoLocation || '',
+                            proxySessionId: request.proxySessionId || '',
+                            id: tunnelId
+                        },
+                    },
+                    { tunnelMessage: { tunnelId, message } }
+                ]);
+                try {
+                    await makeTunnel();
+                    // wait for tunnel to be successfully created
+                    await client.waitForResponse(createTunnelReqId);
+                }
+                catch (err) {
+                    onConnectionClose(err);
+                }
+                return;
+            }
+            return tunnel.write(message);
+        },
+        onRead(packet, ctx) {
+            transcript.push({
+                sender: 'server',
+                message: {
+                    ...ctx,
+                    data: concatenateUint8Arrays([
+                        packet.header,
+                        // the TLS package sends us the decrypted
+                        // content, so we need to get the orginal
+                        // ciphertext received from the server
+                        // as that's part of the true transcript.
+                        ctx.type === 'ciphertext'
+                            ? ctx.ciphertext
+                            : packet.content
+                    ])
+                }
+            });
+        },
+    });
+    await tls.startHandshake();
+    // wait for handshake completion
+    await waitForHandshake;
+    handshakeResolve = handshakeReject = undefined;
+    return {
+        transcript,
+        tls,
+        write(data) {
+            return tls.write(data);
+        },
+        async close(err) {
+            onConnectionClose(err);
+            try {
+                await tunnel.close(err);
             }
-          },
-          { tunnelMessage: { tunnelId, message } }
-        ]);
-        try {
-          await makeTunnel();
-          await client.waitForResponse(createTunnelReqId);
-        } catch (err) {
-          onConnectionClose(err);
-        }
-        return;
-      }
-      return tunnel.write(message);
-    },
-    onRead(packet, ctx) {
-      transcript.push({
-        sender: "server",
-        message: {
-          ...ctx,
-          data: concatenateUint8Arrays([
-            packet.header,
-            // the TLS package sends us the decrypted
-            // content, so we need to get the orginal
-            // ciphertext received from the server
-            // as that's part of the true transcript.
-            ctx.type === "ciphertext" ? ctx.ciphertext : packet.content
-          ])
-        }
-      });
+            catch (err) {
+                logger?.error({ err }, 'err in close tunnel');
+            }
+        },
+    };
+    function onConnectionClose(err) {
+        onClose?.(err);
+        // once the TLS connection is closed, we no longer
+        // want to send `onClose` events back to the caller
+        // of this function.
+        onClose = undefined;
+        handshakeReject?.(err || new Error('TLS connection closed'));
     }
-  });
-  await tls.startHandshake();
-  await waitForHandshake;
-  handshakeResolve = handshakeReject = void 0;
-  return {
-    transcript,
-    tls,
-    write(data) {
-      return tls.write(data);
-    },
-    async close(err) {
-      onConnectionClose(err);
-      try {
-        await tunnel.close(err);
-      } catch (err2) {
-        logger?.error({ err: err2 }, "err in close tunnel");
-      }
+    async function makeTunnel() {
+        tunnel = await makeRpcTcpTunnel({
+            tunnelId,
+            client: client,
+            onMessage(data) {
+                tls.handleReceivedBytes(data);
+            },
+            onClose(err) {
+                tls.end(err);
+            },
+        });
+        logger?.debug('plaintext tunnel created');
+        return tunnel;
     }
-  };
-  function onConnectionClose(err) {
-    onClose?.(err);
-    onClose = void 0;
-    handshakeReject?.(
-      err || new Error("TLS connection closed")
-    );
-  }
-  async function makeTunnel() {
-    tunnel = await makeRpcTcpTunnel({
-      tunnelId,
-      client,
-      onMessage(data) {
-        tls.handleReceivedBytes(data);
-      },
-      onClose(err) {
-        tls.end(err);
-      }
-    });
-    logger?.debug("plaintext tunnel created");
-    return tunnel;
-  }
-};
-export {
-  makeRpcTlsTunnel
 };

package/lib/client/utils/attestor-pool.js

@@ -1,24 +1,25 @@
-import { AttestorClient } from "../../client/utils/client-socket.js";
+import { AttestorClient } from "./client-socket.js";
 const POOL = {};
-function getAttestorClientFromPool(url, getCreateOpts = () => ({})) {
-  const key = url.toString();
-  let client = POOL[key];
-  let createReason;
-  if (client?.isClosed) {
-    createReason = "closed";
-  } else if (!client) {
-    createReason = "non-existent";
-  }
-  if (createReason) {
-    const createOpts = getCreateOpts();
-    createOpts?.logger?.info(
-      { key, createReason },
-      "creating new client"
-    );
-    client = POOL[key] = new AttestorClient({ ...createOpts, url });
-  }
-  return client;
+/**
+ * Get a attestor client from the pool,
+ * if it doesn't exist, create one.
+ * @param [getCreateOpts] - Function to get the options for creating a new client.
+ *  called synchronously, in the same tick as this function.
+ */
+export function getAttestorClientFromPool(url, getCreateOpts = () => ({})) {
+    const key = url.toString();
+    let client = POOL[key];
+    let createReason;
+    if (client?.isClosed) {
+        createReason = 'closed';
+    }
+    else if (!client) {
+        createReason = 'non-existent';
+    }
+    if (createReason) {
+        const createOpts = getCreateOpts();
+        createOpts?.logger?.info({ key, createReason }, 'creating new client');
+        client = (POOL[key] = new AttestorClient({ ...createOpts, url }));
+    }
+    return client;
 }
-export {
-  getAttestorClientFromPool
-};

package/lib/client/utils/client-socket.js

@@ -1,120 +1,97 @@
-import { encodeBase64 } from "ethers";
+import { encodeBase64 } from 'ethers';
 import { DEFAULT_METADATA, DEFAULT_RPC_TIMEOUT_MS } from "../../config/index.js";
 import { RPCMessages } from "../../proto/api.js";
 import { AttestorError, generateRpcMessageId, getRpcRequestType, logger as LOGGER, packRpcMessages } from "../../utils/index.js";
 import { AttestorSocket } from "../../utils/socket-base.js";
 import { makeWebSocket as defaultMakeWebSocket } from "../../utils/ws.js";
-class AttestorClient extends AttestorSocket {
-  waitForInitPromise;
-  initResponse;
-  constructor({
-    url,
-    initMessages = [],
-    signatureType = DEFAULT_METADATA.signatureType,
-    logger = LOGGER,
-    authRequest,
-    makeWebSocket = defaultMakeWebSocket
-  }) {
-    const initRequest = {
-      ...DEFAULT_METADATA,
-      signatureType,
-      auth: authRequest
-    };
-    const msg = packRpcMessages({ initRequest }, ...initMessages);
-    const initRequestBytes = RPCMessages.encode(msg).finish();
-    const initRequestB64 = encodeBase64(initRequestBytes);
-    url = new URL(url.toString());
-    url.searchParams.set("messages", initRequestB64);
-    super(
-      makeWebSocket(url),
-      initRequest,
-      logger
-    );
-    const initReqId = msg.messages[0].id;
-    this.waitForInitPromise = this.waitForResponse(initReqId, DEFAULT_RPC_TIMEOUT_MS).then((res) => {
-      logger.info("client initialised");
-      this.isInitialised = true;
-      this.initResponse = res;
-    });
-    this.waitForInitPromise.catch(() => {
-    });
-    this.addEventListener("connection-terminated", (ev) => logger.info({ err: ev.data }, "connection terminated"));
-  }
-  async rpc(type, request, timeoutMs = DEFAULT_RPC_TIMEOUT_MS) {
-    const msgId = generateRpcMessageId();
-    this.logger.debug({ type, id: msgId }, "sending rpc request");
-    const now = Date.now();
-    try {
-      const rslt = this.waitForResponse(msgId, timeoutMs);
-      await this.sendMessage({ id: msgId, [getRpcRequestType(type)]: request });
-      return await rslt;
-    } finally {
-      const timeTakenMs = Date.now() - now;
-      this.logger.debug({ type, timeTakenMs }, "received rpc response");
-    }
-  }
-  waitForResponse(id, timeoutMs = DEFAULT_RPC_TIMEOUT_MS) {
-    if (this.isClosed) {
-      throw new AttestorError(
-        "ERROR_NETWORK_ERROR",
-        "Client connection already closed"
-      );
+export class AttestorClient extends AttestorSocket {
+    waitForInitPromise;
+    initResponse;
+    constructor({ url, initMessages = [], signatureType = DEFAULT_METADATA.signatureType, logger = LOGGER, authRequest, makeWebSocket = defaultMakeWebSocket }) {
+        const initRequest = {
+            ...DEFAULT_METADATA,
+            signatureType,
+            auth: authRequest
+        };
+        const msg = packRpcMessages({ initRequest }, ...initMessages);
+        const initRequestBytes = RPCMessages.encode(msg).finish();
+        const initRequestB64 = encodeBase64(initRequestBytes);
+        url = new URL(url.toString());
+        url.searchParams.set('messages', initRequestB64);
+        super(makeWebSocket(url), initRequest, logger);
+        const initReqId = msg.messages[0].id;
+        this.waitForInitPromise = this
+            .waitForResponse(initReqId, DEFAULT_RPC_TIMEOUT_MS)
+            .then(res => {
+            logger.info('client initialised');
+            this.isInitialised = true;
+            this.initResponse = res;
+        });
+        // swallow the error if anything bad happens, and we've no
+        // catch block to handle it
+        this.waitForInitPromise
+            .catch(() => { });
+        this.addEventListener('connection-terminated', ev => (logger.info({ err: ev.data }, 'connection terminated')));
     }
-    return new Promise((resolve, reject) => {
-      const handler = (event) => {
-        if (event.data.id !== id) {
-          return;
+    async rpc(type, request, timeoutMs = DEFAULT_RPC_TIMEOUT_MS) {
+        const msgId = generateRpcMessageId();
+        this.logger.debug({ type, id: msgId }, 'sending rpc request');
+        const now = Date.now();
+        try {
+            const rslt = this.waitForResponse(msgId, timeoutMs);
+            await this.sendMessage({ id: msgId, [getRpcRequestType(type)]: request });
+            return await rslt;
         }
-        removeHandlers();
-        if ("error" in event.data) {
-          reject(event.data.error);
-          return;
+        finally {
+            const timeTakenMs = Date.now() - now;
+            this.logger.debug({ type, timeTakenMs }, 'received rpc response');
         }
-        resolve(event.data.data);
-      };
-      const terminateHandler = (event) => {
-        removeHandlers();
-        if (event.data.code === "ERROR_NO_ERROR") {
-          reject(
-            new AttestorError(
-              "ERROR_NETWORK_ERROR",
-              event.data.message,
-              event.data.data
-            )
-          );
-          return;
+    }
+    waitForResponse(id, timeoutMs = DEFAULT_RPC_TIMEOUT_MS) {
+        if (this.isClosed) {
+            throw new AttestorError('ERROR_NETWORK_ERROR', 'Client connection already closed');
         }
-        reject(event.data);
-      };
-      const timeout = setTimeout(() => {
-        removeHandlers();
-        reject(
-          new AttestorError(
-            "ERROR_TIMEOUT",
-            `RPC request timed out after ${timeoutMs}ms`,
-            { id }
-          )
-        );
-      }, timeoutMs);
-      const removeHandlers = () => {
-        clearTimeout(timeout);
-        this.removeEventListener("rpc-response", handler);
-        this.removeEventListener("connection-terminated", terminateHandler);
-      };
-      this.addEventListener("rpc-response", handler);
-      this.addEventListener("connection-terminated", terminateHandler);
-    });
-  }
-  waitForInit = () => {
-    if (this.isClosed) {
-      throw new AttestorError(
-        "ERROR_NETWORK_ERROR",
-        "Client connection already closed"
-      );
+        // setup a promise to wait for the response
+        return new Promise((resolve, reject) => {
+            const handler = (event) => {
+                if (event.data.id !== id) {
+                    return;
+                }
+                removeHandlers();
+                if ('error' in event.data) {
+                    reject(event.data.error);
+                    return;
+                }
+                // @ts-expect-error
+                resolve(event.data.data);
+            };
+            const terminateHandler = (event) => {
+                removeHandlers();
+                // if the connection was terminated, reject the promise
+                // but update the error code to reflect the network error
+                if (event.data.code === 'ERROR_NO_ERROR') {
+                    reject(new AttestorError('ERROR_NETWORK_ERROR', event.data.message, event.data.data));
+                    return;
+                }
+                reject(event.data);
+            };
+            const timeout = setTimeout(() => {
+                removeHandlers();
+                reject(new AttestorError('ERROR_TIMEOUT', `RPC request timed out after ${timeoutMs}ms`, { id }));
+            }, timeoutMs);
+            const removeHandlers = () => {
+                clearTimeout(timeout);
+                this.removeEventListener('rpc-response', handler);
+                this.removeEventListener('connection-terminated', terminateHandler);
+            };
+            this.addEventListener('rpc-response', handler);
+            this.addEventListener('connection-terminated', terminateHandler);
+        });
     }
-    return this.waitForInitPromise;
-  };
+    waitForInit = () => {
+        if (this.isClosed) {
+            throw new AttestorError('ERROR_NETWORK_ERROR', 'Client connection already closed');
+        }
+        return this.waitForInitPromise;
+    };
 }
-export {
-  AttestorClient
-};