@reclaimprotocol/attestor-core 3.0.1

package/lib/avs/utils/register.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerOperator = registerOperator;
+const ethers_1 = require("ethers");
+const config_1 = require("src/avs/config");
+const contracts_1 = require("src/avs/utils/contracts");
+const utils_1 = require("src/utils");
+/**
+ * Registers the operator on the chain, if required.
+ * If already registered -- will just pass through
+ */
+async function registerOperator({ logger = utils_1.logger, chainId = config_1.SELECTED_CHAIN_ID, wallet = (0, contracts_1.getContracts)(chainId).wallet, reclaimRpcUrl = config_1.RECLAIM_PUBLIC_URL } = {}) {
+    const contracts = (0, contracts_1.getContracts)(chainId);
+    const delegationManager = contracts.delegationManager
+        .connect(wallet);
+    const avsDirectory = contracts.avsDirectory
+        .connect(wallet);
+    const contract = contracts.contract
+        .connect(wallet);
+    const registryContract = contracts.registryContract
+        .connect(wallet);
+    const addr = await wallet.address;
+    try {
+        const tx1 = await delegationManager
+            .registerAsOperator({
+            earningsReceiver: addr,
+            delegationApprover: '0x0000000000000000000000000000000000000000',
+            stakerOptOutWindowBlocks: 0
+        }, '');
+        await tx1.wait();
+        logger.info('operator registered on DM successfully');
+    }
+    catch (err) {
+        if (!err.message.includes('operator has already registered')) {
+            throw err;
+        }
+        logger.info('Operator already registered on EL');
+    }
+    const salt = ethers_1.ethers.utils.hexlify(ethers_1.ethers.utils.randomBytes(32));
+    // Example expiry, 1 hour from now
+    const expiry = Math.floor(Date.now() / 1000) + 3600;
+    // Define the output structure
+    const operatorSignature = {
+        expiry: expiry,
+        salt: salt,
+        signature: ''
+    };
+    // Calculate the digest hash using the avsDirectory's method
+    const digestHash = await avsDirectory
+        .calculateOperatorAVSRegistrationDigestHash(addr, contract.address, salt, expiry);
+    // Sign the digest hash with the operator's private key
+    const signingKey = new ethers_1.ethers.utils.SigningKey(wallet.privateKey);
+    const signature = signingKey.signDigest(digestHash);
+    // Encode the signature in the required format
+    operatorSignature.signature = ethers_1.ethers.utils.joinSignature(signature);
+    logger.info('operator signature generated successfully');
+    if (!(await registryContract.operatorRegistered(addr))) {
+        const tx2 = await registryContract
+            .registerOperatorWithSignature(addr, operatorSignature);
+        await tx2.wait();
+        logger.info('operator registered on AVS successfully');
+    }
+    else {
+        logger.info('Operator already registered on AVS');
+    }
+    const existingMetadata = await contract.getMetadataForOperator(addr);
+    const metadata = { addr, url: reclaimRpcUrl };
+    if (existingMetadata.addr === metadata.addr
+        && existingMetadata.url === metadata.url) {
+        logger.info('operator metadata already up to date');
+        return;
+    }
+    await contract.updateOperatorMetadata(metadata);
+    logger.info({ metadata }, 'operator metadata updated successfully');
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/avs/utils/tasks.d.ts

@@ -0,0 +1,22 @@
+import { ethers, type Wallet } from 'ethers';
+import type { IReclaimServiceManager, NewTaskCreatedEventObject } from 'src/avs/contracts/ReclaimServiceManager';
+type CreateClaimWithoutOwner = Omit<IReclaimServiceManager.ClaimRequestStruct, 'owner'>;
+type CreateNewClaimRequestOnChainOpts = {
+    request: CreateClaimWithoutOwner;
+    payer: Wallet;
+    chainId?: string;
+} & ({
+    owner: Wallet;
+} | {
+    /**
+     * Address of the owner of the claim
+     */
+    owner: string;
+    requestSignature?: string | Uint8Array;
+});
+export declare function createNewClaimRequestOnChain({ request, payer, chainId, ...rest }: CreateNewClaimRequestOnChainOpts): Promise<{
+    task: NewTaskCreatedEventObject;
+    tx: ethers.ContractReceipt;
+}>;
+export declare function signClaimRequest(request: IReclaimServiceManager.ClaimRequestStruct, owner: Wallet, chainId?: string): Promise<Uint8Array>;
+export {};

package/lib/avs/utils/tasks.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createNewClaimRequestOnChain = createNewClaimRequestOnChain;
+exports.signClaimRequest = signClaimRequest;
+const ethers_1 = require("ethers");
+const contracts_1 = require("src/avs/utils/contracts");
+async function createNewClaimRequestOnChain({ request, payer, chainId, ...rest }) {
+    const contracts = (0, contracts_1.getContracts)(chainId);
+    const contract = contracts.contract.connect(payer);
+    const ownerAddress = typeof rest.owner === 'string'
+        ? rest.owner
+        : rest.owner.address;
+    const fullRequest = {
+        ...request,
+        owner: ownerAddress
+    };
+    const signature = await getSignature();
+    const task = await contract.createNewTask(fullRequest, signature || '0x00');
+    const rslt = await task.wait();
+    const events = rslt.events;
+    // check task created event was emitted
+    const ev = events === null || events === void 0 ? void 0 : events[0];
+    const arg = ev === null || ev === void 0 ? void 0 : ev.args;
+    return { task: arg, tx: rslt };
+    function getSignature() {
+        if (ownerAddress.toLowerCase() === payer.address.toLowerCase()) {
+            return;
+        }
+        if ('requestSignature' in rest) {
+            return rest.requestSignature;
+        }
+        if (typeof rest.owner !== 'object') {
+            throw new Error('Owner wallet must be provided or'
+                + ' requestSignature must be provided');
+        }
+        return signClaimRequest(fullRequest, rest.owner, chainId);
+    }
+}
+async function signClaimRequest(request, owner, chainId) {
+    const contract = (0, contracts_1.getContracts)(chainId).contract;
+    const encoded = await contract.encodeClaimRequest(request);
+    const strSig = await owner.signMessage(ethers_1.ethers.utils.arrayify(encoded));
+    return ethers_1.ethers.utils.arrayify(strSig);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/client/create-claim.d.ts

@@ -0,0 +1,5 @@
+import { CreateClaimOnAttestorOpts, ProviderName } from 'src/types';
+/**
+ * Create a claim on the attestor
+ */
+export declare function createClaimOnAttestor<N extends ProviderName>({ logger: _logger, ...opts }: CreateClaimOnAttestorOpts<N>): Promise<import("src/proto/api").ClaimTunnelResponse>;

package/lib/client/create-claim.js

@@ -0,0 +1,357 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createClaimOnAttestor = createClaimOnAttestor;
+const tls_1 = require("@reclaimprotocol/tls");
+const utils_1 = require("ethers/lib/utils");
+const make_rpc_tls_tunnel_1 = require("src/client/tunnels/make-rpc-tls-tunnel");
+const attestor_pool_1 = require("src/client/utils/attestor-pool");
+const config_1 = require("src/config");
+const api_1 = require("src/proto/api");
+const providers_1 = require("src/providers");
+const utils_2 = require("src/utils");
+const retries_1 = require("src/utils/retries");
+const signatures_1 = require("src/utils/signatures");
+const tls_2 = require("src/utils/tls");
+/**
+ * Create a claim on the attestor
+ */
+function createClaimOnAttestor({ logger: _logger, ...opts }) {
+    const logger = _logger
+        // if the client has already been initialised
+        // and no logger is provided, use the client's logger
+        // otherwise default to the global logger
+        || ('logger' in opts.client ? opts.client.logger : utils_2.logger);
+    return (0, retries_1.executeWithRetries)(attempt => (_createClaimOnAttestor({
+        ...opts,
+        logger: attempt
+            ? logger.child({ attempt })
+            : logger
+    })), { logger, shouldRetry });
+}
+function shouldRetry(err) {
+    if (err instanceof TypeError) {
+        return false;
+    }
+    return err instanceof utils_2.AttestorError
+        && err.code !== 'ERROR_INVALID_CLAIM'
+        && err.code !== 'ERROR_BAD_REQUEST';
+}
+async function _createClaimOnAttestor({ name, params, secretParams, context, onStep, ownerPrivateKey, client: clientInit, logger = utils_2.logger, timestampS, updateProviderParams, ...zkOpts }) {
+    const provider = providers_1.providers[name];
+    const hostPort = (0, utils_2.getProviderValue)(params, provider.hostPort);
+    const geoLocation = (0, utils_2.getProviderValue)(params, provider.geoLocation);
+    const providerTlsOpts = (0, utils_2.getProviderValue)(params, provider.additionalClientOptions);
+    const tlsOpts = {
+        ...(0, tls_2.getDefaultTlsOptions)(),
+        ...providerTlsOpts,
+    };
+    let redactionMode = (0, utils_2.getProviderValue)(params, provider.writeRedactionMode);
+    const [host, port] = hostPort.split(':');
+    const resParser = (0, utils_2.makeHttpResponseParser)();
+    let client;
+    let lastMsgRevealed = false;
+    const revealMap = new Map();
+    onStep === null || onStep === void 0 ? void 0 : onStep({ name: 'connecting' });
+    let endedHttpRequest;
+    const createTunnelReq = {
+        host,
+        port: port ? +port : config_1.DEFAULT_HTTPS_PORT,
+        geoLocation,
+        id: (0, utils_2.generateTunnelId)()
+    };
+    const tunnel = await (0, make_rpc_tls_tunnel_1.makeRpcTlsTunnel)({
+        tlsOpts,
+        connect: (initMessages) => {
+            let created = false;
+            if ('metadata' in clientInit) {
+                client = clientInit;
+            }
+            else {
+                client = (0, attestor_pool_1.getAttestorClientFromPool)(clientInit.url, () => {
+                    created = true;
+                    return { initMessages, logger };
+                });
+            }
+            if (!created) {
+                client
+                    .waitForInit()
+                    .then(() => client.sendMessage(...initMessages))
+                    .catch(err => {
+                    logger.error({ err }, 'error in sending init msgs');
+                });
+            }
+            return client;
+        },
+        logger,
+        request: createTunnelReq,
+        onMessage(data) {
+            logger.debug({ bytes: data.length }, 'recv data from server');
+            resParser.onChunk(data);
+            if (resParser.res.complete) {
+                logger === null || logger === void 0 ? void 0 : logger.debug('got complete HTTP response from server');
+                // wait a little bit to make sure the client has
+                // finished writing the response
+                setTimeout(() => {
+                    endedHttpRequest === null || endedHttpRequest === void 0 ? void 0 : endedHttpRequest();
+                }, 100);
+            }
+        },
+        onClose(err) {
+            const level = err ? 'error' : 'debug';
+            logger === null || logger === void 0 ? void 0 : logger[level]({ err }, 'tls session ended');
+            endedHttpRequest === null || endedHttpRequest === void 0 ? void 0 : endedHttpRequest(err);
+            try {
+                resParser.streamEnded();
+            }
+            catch (_a) { }
+        },
+    });
+    const { version: tlsVersion, cipherSuite } = tunnel.tls.getMetadata();
+    if (tlsVersion === 'TLS1_2' && redactionMode !== 'zk') {
+        redactionMode = 'zk';
+        logger.info('TLS1.2 detected, defaulting to zk redaction mode');
+    }
+    const { redactions, data: requestStr } = provider.createRequest(
+    // @ts-ignore
+    secretParams, params);
+    const requestData = typeof requestStr === 'string'
+        ? (0, tls_1.strToUint8Array)(requestStr)
+        : requestStr;
+    logger.debug({ redactions: redactions.length }, 'generated request');
+    const waitForAllData = new Promise((resolve, reject) => {
+        endedHttpRequest = err => (err ? reject(err) : resolve());
+    });
+    onStep === null || onStep === void 0 ? void 0 : onStep({ name: 'sending-request-data' });
+    try {
+        if (redactionMode === 'zk') {
+            await writeRedactedZk();
+        }
+        else {
+            await writeRedactedWithKeyUpdate();
+        }
+        logger.info('wrote request to server');
+    }
+    catch (err) {
+        // wait for complete stream end when the session is closed
+        // mid-write, as this means the server could not process
+        // our request due to some error. Hope the stream end
+        // error will be more descriptive
+        logger.error({ err }, 'session errored during write, waiting for stream end');
+    }
+    onStep === null || onStep === void 0 ? void 0 : onStep({ name: 'waiting-for-response' });
+    await waitForAllData;
+    await tunnel.close();
+    logger.info('got full response from server');
+    // update the response selections
+    if (updateProviderParams) {
+        const { params: updatedParms, secretParams: updatedSecretParms } = await updateProviderParams(tunnel.transcript, tlsVersion !== null && tlsVersion !== void 0 ? tlsVersion : 'TLS1_2');
+        params = { ...params, ...updatedParms };
+        secretParams = { ...secretParams, ...updatedSecretParms };
+    }
+    const signatureAlg = signatures_1.SIGNATURES[client.metadata.signatureType];
+    let serverIV;
+    let clientIV;
+    const serverBlock = getLastBlock('server');
+    if (serverBlock && serverBlock.message.type === 'ciphertext') {
+        serverIV = serverBlock.message.fixedIv;
+    }
+    const clientBlock = getLastBlock('client');
+    if (clientBlock && clientBlock.message.type === 'ciphertext') {
+        clientIV = clientBlock.message.fixedIv;
+    }
+    // now that we have the full transcript, we need
+    // to generate the ZK proofs & send them to the attestor
+    // to verify & sign our claim
+    const claimTunnelReq = api_1.ClaimTunnelRequest.create({
+        request: createTunnelReq,
+        data: {
+            provider: name,
+            parameters: (0, utils_2.canonicalStringify)(params),
+            context: (0, utils_2.canonicalStringify)(context),
+            timestampS: timestampS !== null && timestampS !== void 0 ? timestampS : (0, utils_2.unixTimestampSeconds)(),
+            owner: getAddress(),
+        },
+        transcript: await generateTranscript(),
+        zkEngine: zkOpts.zkEngine === 'gnark' ? api_1.ZKProofEngine.ZK_ENGINE_GNARK : api_1.ZKProofEngine.ZK_ENGINE_SNARKJS,
+        fixedServerIV: serverIV,
+        fixedClientIV: clientIV,
+    });
+    onStep === null || onStep === void 0 ? void 0 : onStep({ name: 'waiting-for-verification' });
+    const claimTunnelBytes = api_1.ClaimTunnelRequest
+        .encode(claimTunnelReq).finish();
+    const requestSignature = await signatureAlg
+        .sign(claimTunnelBytes, ownerPrivateKey);
+    claimTunnelReq.signatures = { requestSignature };
+    const result = await client.rpc('claimTunnel', claimTunnelReq);
+    logger.info({ success: !!result.claim }, 'recv claim response');
+    return result;
+    async function writeRedactedWithKeyUpdate() {
+        var _a;
+        let currentIndex = 0;
+        for (const section of redactions) {
+            const block = requestData
+                .slice(currentIndex, section.fromIndex);
+            if (block.length) {
+                await writeWithReveal(block, true);
+            }
+            const redacted = requestData
+                .slice(section.fromIndex, section.toIndex);
+            await writeWithReveal(redacted, false);
+            currentIndex = section.toIndex;
+        }
+        // write if redactions were there
+        const lastBlockStart = ((_a = redactions === null || redactions === void 0 ? void 0 : redactions[redactions.length - 1]) === null || _a === void 0 ? void 0 : _a.toIndex) || 0;
+        const block = requestData.slice(lastBlockStart);
+        if (block.length) {
+            await writeWithReveal(block, true);
+        }
+    }
+    async function writeRedactedZk() {
+        await tunnel.tls.write(requestData);
+        setRevealOfLastSentBlock({
+            type: 'zk',
+            redactedPlaintext: (0, utils_2.redactSlices)(requestData, redactions)
+        });
+    }
+    /**
+     * Write data to the tunnel, with the option to mark the packet
+     * as revealable to the attestor or not
+     */
+    async function writeWithReveal(data, reveal) {
+        // if the reveal state has changed, update the traffic keys
+        // to not accidentally reveal a packet not meant to be revealed
+        // and vice versa
+        if (reveal !== lastMsgRevealed) {
+            await tunnel.tls.updateTrafficKeys();
+        }
+        await tunnel.write(data);
+        // now we mark the packet to be revealed to the attestor
+        setRevealOfLastSentBlock(reveal ? { type: 'complete' } : undefined);
+        lastMsgRevealed = reveal;
+    }
+    function setRevealOfLastSentBlock(reveal) {
+        const lastBlock = getLastBlock('client');
+        if (!lastBlock) {
+            return;
+        }
+        setRevealOfMessage(lastBlock.message, reveal);
+    }
+    function getLastBlock(sender) {
+        // set the correct index for the server blocks
+        for (let i = tunnel.transcript.length - 1; i >= 0; i--) {
+            const block = tunnel.transcript[i];
+            if (block.sender === sender) {
+                return block;
+            }
+        }
+    }
+    /**
+     * Generate transcript with reveal data for the attestor to verify
+     */
+    async function generateTranscript() {
+        addServerSideReveals();
+        const startMs = Date.now();
+        const revealedMessages = await (0, utils_2.preparePacketsForReveal)(tunnel.transcript, revealMap, {
+            logger,
+            cipherSuite: cipherSuite,
+            onZkProgress(done, total) {
+                const timeSinceStartMs = Date.now() - startMs;
+                const timePerBlockMs = timeSinceStartMs / done;
+                const timeLeftMs = timePerBlockMs * (total - done);
+                onStep === null || onStep === void 0 ? void 0 : onStep({
+                    name: 'generating-zk-proofs',
+                    proofsDone: done,
+                    proofsTotal: total,
+                    approxTimeLeftS: Math.round(timeLeftMs / 1000),
+                });
+            },
+            ...zkOpts,
+        });
+        return revealedMessages;
+    }
+    /**
+     * Add reveals for server side blocks, using
+     * the provider's redaction function if available.
+     * Otherwise, opts to reveal all server side blocks.
+     */
+    function addServerSideReveals() {
+        const allPackets = tunnel.transcript;
+        let serverPacketsToReveal = 'all';
+        const packets = [];
+        const serverBlocks = [];
+        for (const b of allPackets) {
+            if (b.message.type !== 'ciphertext'
+                || !(0, utils_2.isApplicationData)(b.message, tlsVersion)) {
+                continue;
+            }
+            const plaintext = tlsVersion === 'TLS1_3'
+                ? b.message.plaintext.slice(0, -1)
+                : b.message.plaintext;
+            packets.push({
+                message: plaintext,
+                sender: b.sender
+            });
+            if (b.sender === 'server') {
+                serverBlocks.push({
+                    plaintext: plaintext,
+                    message: b.message
+                });
+            }
+        }
+        provider.assertValidProviderReceipt(packets, {
+            ...params,
+            secretParams: secretParams //provide secret params for proper request body validation
+        });
+        if (provider.getResponseRedactions) {
+            serverPacketsToReveal = (0, utils_2.getBlocksToReveal)(serverBlocks, total => provider.getResponseRedactions(total, params));
+        }
+        if (serverPacketsToReveal === 'all') {
+            // reveal all server side blocks
+            for (const { message, sender } of allPackets) {
+                if (sender === 'server') {
+                    setRevealOfMessage(message, { type: 'complete' });
+                }
+            }
+        }
+        else {
+            for (const { block, redactedPlaintext } of serverPacketsToReveal) {
+                setRevealOfMessage(block.message, {
+                    type: 'zk',
+                    redactedPlaintext
+                });
+            }
+            if (Array.isArray(serverPacketsToReveal)) {
+                const msgs = serverPacketsToReveal.map(m => m.redactedPlaintext);
+                const serverTranscript = utils_1.base64.encode((0, tls_1.concatenateUint8Arrays)(msgs));
+                logger.debug({ redactedResponse: serverTranscript });
+            }
+        }
+        // reveal all handshake blocks
+        // so the attestor can verify there was no
+        // hanky-panky
+        for (const p of allPackets) {
+            if (p.message.type !== 'ciphertext') {
+                continue;
+            }
+            // break the moment we hit the first
+            // application data packet
+            if ((0, utils_2.isApplicationData)(p.message, tlsVersion)) {
+                break;
+            }
+            setRevealOfMessage(p.message, { type: 'complete' });
+        }
+    }
+    function setRevealOfMessage(message, reveal) {
+        if (reveal) {
+            revealMap.set(message, reveal);
+            return;
+        }
+        revealMap.delete(message);
+    }
+    function getAddress() {
+        const { getAddress, getPublicKey, } = signatureAlg;
+        const pubKey = getPublicKey(ownerPrivateKey);
+        return getAddress(pubKey);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"create-claim.js","sourceRoot":"","sources":["../../src/client/create-claim.ts"],"names":[],"mappings":"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"}

package/lib/client/index.d.ts

@@ -0,0 +1,3 @@
+export * from './create-claim';
+export * from './utils/attestor-pool';
+export * from './utils/client-socket';

package/lib/client/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./create-claim"), exports);
+__exportStar(require("./utils/attestor-pool"), exports);
+__exportStar(require("./utils/client-socket"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvY2xpZW50L2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7QUFBQSxpREFBOEI7QUFDOUIsd0RBQXFDO0FBQ3JDLHdEQUFxQyJ9

package/lib/client/tunnels/make-rpc-tcp-tunnel.d.ts

@@ -0,0 +1,16 @@
+import { CreateTunnelRequest } from 'src/proto/api';
+import { IAttestorClient, MakeTunnelFn } from 'src/types';
+export type TCPTunnelCreateOpts = {
+    /**
+     * The tunnel ID to communicate with.
+     */
+    tunnelId: CreateTunnelRequest['id'];
+    client: IAttestorClient;
+};
+/**
+ * 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 declare const makeRpcTcpTunnel: MakeTunnelFn<TCPTunnelCreateOpts>;

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

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeRpcTcpTunnel = void 0;
+const utils_1 = require("src/utils");
+/**
+ * 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.
+ */
+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 {
+        write(message) {
+            return 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 === null || onMessage === void 0 ? void 0 : onMessage(data.message);
+    }
+    function onDisconnectListener({ data }) {
+        var _a;
+        if (data.tunnelId !== tunnelId) {
+            return;
+        }
+        onErrorRecv(((_a = data.error) === null || _a === void 0 ? void 0 : _a.code)
+            ? utils_1.AttestorError.fromProto(data.error)
+            : undefined);
+    }
+    function onConnectionTerminatedListener({ data }) {
+        onErrorRecv(data);
+    }
+    function onErrorRecv(err) {
+        var _a;
+        (_a = client.logger) === null || _a === void 0 ? void 0 : _a.debug({ tunnelId, err }, 'TCP tunnel closed');
+        client.removeEventListener('tunnel-message', onMessageListener);
+        client.removeEventListener('tunnel-disconnect-event', onDisconnectListener);
+        client.removeEventListener('connection-terminated', onConnectionTerminatedListener);
+        onClose === null || onClose === void 0 ? void 0 : onClose(err);
+        onClose = undefined;
+        closed = true;
+    }
+};
+exports.makeRpcTcpTunnel = makeRpcTcpTunnel;
+//# sourceMappingURL=data:application/json;base64,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