@atomicfinance/types 4.1.3 → 4.1.4

package/.yalc/@node-dlc/noise/dist/index.js

@@ -0,0 +1,69 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createServer = exports.connect = exports.NoiseState = exports.NoiseSocket = exports.NoiseServer = exports.NoiseError = void 0;
+const crypto = __importStar(require("@node-dlc/crypto"));
+const net_1 = require("net");
+const noise_server_1 = require("./noise-server");
+const noise_socket_1 = require("./noise-socket");
+const noise_state_1 = require("./noise-state");
+var noise_error_1 = require("./noise-error");
+Object.defineProperty(exports, "NoiseError", { enumerable: true, get: function () { return noise_error_1.NoiseError; } });
+var noise_server_2 = require("./noise-server");
+Object.defineProperty(exports, "NoiseServer", { enumerable: true, get: function () { return noise_server_2.NoiseServer; } });
+var noise_socket_2 = require("./noise-socket");
+Object.defineProperty(exports, "NoiseSocket", { enumerable: true, get: function () { return noise_socket_2.NoiseSocket; } });
+var noise_state_2 = require("./noise-state");
+Object.defineProperty(exports, "NoiseState", { enumerable: true, get: function () { return noise_state_2.NoiseState; } });
+/**
+ * Connect to a remote noise socket server.
+ */
+function connect({ ls, es, rpk, host, port = 9735, logger, }) {
+    if (!es) {
+        es = crypto.createPrivateKey();
+    }
+    const noiseLogger = logger
+        ? logger.sub('noise', rpk.slice(0, 8).toString('hex'))
+        : undefined;
+    const noiseState = new noise_state_1.NoiseState({ ls, es, logger: noiseLogger });
+    const socket = new net_1.Socket();
+    const instance = new noise_socket_1.NoiseSocket({
+        socket,
+        noiseState,
+        rpk,
+        logger: noiseLogger,
+    });
+    socket.connect({ host, port });
+    return instance;
+}
+exports.connect = connect;
+/**
+ * Factory function to create a new server
+ */
+function createServer({ ls, esFactory }, connListener) {
+    return new noise_server_1.NoiseServer({ ls, esFactory }, connListener);
+}
+exports.createServer = createServer;
+//# sourceMappingURL=index.js.map

package/.yalc/@node-dlc/noise/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../lib/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,yDAA2C;AAE3C,6BAA6B;AAE7B,iDAA6C;AAE7C,iDAA6C;AAC7C,+CAA2C;AAE3C,6CAA2C;AAAlC,yGAAA,UAAU,OAAA;AACnB,+CAA6C;AAApC,2GAAA,WAAW,OAAA;AAGpB,+CAA6C;AAApC,2GAAA,WAAW,OAAA;AAEpB,6CAA2C;AAAlC,yGAAA,UAAU,OAAA;AAkCnB;;GAEG;AACH,SAAgB,OAAO,CAAC,EACtB,EAAE,EACF,EAAE,EACF,GAAG,EACH,IAAI,EACJ,IAAI,GAAG,IAAI,EACX,MAAM,GACc;IACpB,IAAI,CAAC,EAAE,EAAE;QACP,EAAE,GAAG,MAAM,CAAC,gBAAgB,EAAE,CAAC;KAChC;IAED,MAAM,WAAW,GAAG,MAAM;QACxB,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,OAAO,EAAE,GAAG,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;QACtD,CAAC,CAAC,SAAS,CAAC;IACd,MAAM,UAAU,GAAG,IAAI,wBAAU,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,MAAM,EAAE,WAAW,EAAE,CAAC,CAAC;IACnE,MAAM,MAAM,GAAG,IAAI,YAAM,EAAE,CAAC;IAC5B,MAAM,QAAQ,GAAG,IAAI,0BAAW,CAAC;QAC/B,MAAM;QACN,UAAU;QACV,GAAG;QACH,MAAM,EAAE,WAAW;KACpB,CAAC,CAAC;IACH,MAAM,CAAC,OAAO,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC,CAAC;IAC/B,OAAO,QAAQ,CAAC;AAClB,CAAC;AAzBD,0BAyBC;AAED;;GAEG;AACH,SAAgB,YAAY,CAC1B,EAAE,EAAE,EAAE,SAAS,EAAsB,EACrC,YAA2C;IAE3C,OAAO,IAAI,0BAAW,CAAC,EAAE,EAAE,EAAE,SAAS,EAAE,EAAE,YAAY,CAAC,CAAC;AAC1D,CAAC;AALD,oCAKC"}

package/.yalc/@node-dlc/noise/dist/noise-error.d.ts

@@ -0,0 +1,3 @@
+export declare class NoiseError extends Error {
+    module: string;
+}

package/.yalc/@node-dlc/noise/dist/noise-error.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NoiseError = void 0;
+class NoiseError extends Error {
+    constructor() {
+        super(...arguments);
+        this.module = 'noise';
+    }
+}
+exports.NoiseError = NoiseError;
+//# sourceMappingURL=noise-error.js.map

package/.yalc/@node-dlc/noise/dist/noise-error.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"noise-error.js","sourceRoot":"","sources":["../lib/noise-error.ts"],"names":[],"mappings":";;;AAAA,MAAa,UAAW,SAAQ,KAAK;IAArC;;QACS,WAAM,GAAG,OAAO,CAAC;IAC1B,CAAC;CAAA;AAFD,gCAEC"}

package/.yalc/@node-dlc/noise/dist/noise-server-listen-options.d.ts

@@ -0,0 +1,23 @@
+export type NoiseServerListenOptions = {
+    /**
+     * Optional port to listen on.  If port is omitted or is 0,
+     * the operating system will assign an arbitrary unused port, which can be retrieved
+     * by using server.address().port after the 'listening' event has been emitted.
+     */
+    port?: number;
+    /**
+     * Optional host to listen on. If host is omitted, the server
+     * will accept connections on the unspecified IPv6 address (::) when IPv6 is available,
+     * or the unspecified IPv4 address (0.0.0.0) otherwise. In most operating systems,
+     * listening to the unspecified IPv6 address (::) may cause NoiseSocket to also
+     * listen on the unspecified IPv4 address (0.0.0.0).
+     */
+    host?: string;
+    /**
+     * Optional value to specify the maximum length of the
+     * queue of pending connections. The actual length will be determined by the OS through
+     * sysctl settings such as tcp_max_syn_backlog and somaxconn on Linux. The default value
+     * of this parameter is 511 (not 512).
+     */
+    backlog?: number;
+};

package/.yalc/@node-dlc/noise/dist/noise-server-listen-options.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=noise-server-listen-options.js.map

package/.yalc/@node-dlc/noise/dist/noise-server-listen-options.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"noise-server-listen-options.js","sourceRoot":"","sources":["../lib/noise-server-listen-options.ts"],"names":[],"mappings":""}

package/.yalc/@node-dlc/noise/dist/noise-server-options.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="node" />
+export type NoiseServerOptions = {
+    /**
+     * Local private key as a 32-byte private key for elliptic curve
+     * secp256k1 used by the server
+     */
+    ls: Buffer;
+    /**
+     * Function for creating the ephemeral private key used by each
+     * connection
+     */
+    esFactory?: () => Buffer;
+};

package/.yalc/@node-dlc/noise/dist/noise-server-options.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=noise-server-options.js.map

package/.yalc/@node-dlc/noise/dist/noise-server-options.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"noise-server-options.js","sourceRoot":"","sources":["../lib/noise-server-options.ts"],"names":[],"mappings":""}

package/.yalc/@node-dlc/noise/dist/noise-server.d.ts

@@ -0,0 +1,71 @@
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+import { EventEmitter } from 'events';
+import { AddressInfo, Socket } from 'net';
+import { NoiseServerListenOptions } from './noise-server-listen-options';
+import { NoiseServerOptions } from './noise-server-options';
+import { NoiseSocket } from './noise-socket';
+export declare class NoiseServer extends EventEmitter {
+    /**
+     * Local private key as a 32-byte private key for elliptic curve
+     * secp256k1 used by the server
+     */
+    ls: Buffer;
+    /**
+     * Function for creating the ephemeral private key used by each
+     * connection
+     */
+    esFactory: () => Buffer;
+    /**
+     * Socket server that is created
+     */
+    private _server;
+    /**
+     * NoiseServer is a TCP server that wraps socket instances
+     * with the NoiseSocket class. This class is an event emitter
+     * with the same interface as net.Server.
+     *
+     * The constructor take arguments that will be used by the
+     * NoiseState.
+     */
+    constructor(opts: NoiseServerOptions, connListener?: (socket: NoiseSocket) => void);
+    /**
+     * Called when the socket receives a new socket connection.
+     * Emits the `connection` event.
+     */
+    _onConnection(socket: Socket): void;
+    /**
+     * Returns the address the server is listeening on. If the server is
+     * not listening, it will return undefined.
+     */
+    address(): string | AddressInfo;
+    /**
+     * Stops the server from accepting new connections and keeps existing connections open.
+     * This function is asynchronous, the server is fully closed when all connections are
+     * ended and the server emits a `close` event. The optional `cb` event will be called
+     * once the `close` event occurs.
+     */
+    close(cb?: (err?: Error) => void): void;
+    /**
+     * Asynchronously get the number of concurrent connections on the server. Works when sockets were sent to forks.
+     */
+    getConnections(cb: (error: Error, count: number) => void): void;
+    /**
+     * Start a server listening for connections. This method is asyncrhonous,
+     * once the server has started listening, the `listening` event will be
+     * emitted.
+     * @param callback Called when the server is listening. Automatically binds
+     * the function to the `listening` event.
+     */
+    listen(opts: NoiseServerListenOptions, callback?: () => void): this;
+    /**
+     * Indicates whether or not the server is listening for connections.
+     */
+    get listening(): boolean;
+    /**
+     * Set this property to reject connections when the server's connection count gets high.
+     */
+    get maxConnections(): number;
+    set maxConnections(val: number);
+}

package/.yalc/@node-dlc/noise/dist/noise-server.js

@@ -0,0 +1,125 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NoiseServer = void 0;
+const crypto = __importStar(require("@node-dlc/crypto"));
+const assert_1 = __importDefault(require("assert"));
+const events_1 = require("events");
+const net_1 = require("net");
+const noise_error_1 = require("./noise-error");
+const noise_socket_1 = require("./noise-socket");
+const noise_state_1 = require("./noise-state");
+class NoiseServer extends events_1.EventEmitter {
+    /**
+     * NoiseServer is a TCP server that wraps socket instances
+     * with the NoiseSocket class. This class is an event emitter
+     * with the same interface as net.Server.
+     *
+     * The constructor take arguments that will be used by the
+     * NoiseState.
+     */
+    constructor(opts, connListener) {
+        super();
+        // localSecret assertions
+        assert_1.default.ok(Buffer.isBuffer(opts.ls), new noise_error_1.NoiseError('ls must be a buffer'));
+        assert_1.default.ok(crypto.validPrivateKey(opts.ls), new noise_error_1.NoiseError('ls must be valid public key'));
+        this.ls = opts.ls;
+        // ephemeral secret factory
+        assert_1.default.ok(!opts.esFactory || typeof opts.esFactory === 'function', new noise_error_1.NoiseError('esFactory must be a function'));
+        this.esFactory = opts.esFactory || crypto.createPrivateKey;
+        // construct and bind the server
+        this._server = new net_1.Server();
+        this._server.on('connection', this._onConnection.bind(this));
+        this._server.on('error', (err) => this.emit('error', err));
+        this._server.on('close', () => this.emit('close'));
+        this._server.on('listening', () => this.emit('listening'));
+        if (connListener)
+            this.on('connection', connListener);
+    }
+    /**
+     * Called when the socket receives a new socket connection.
+     * Emits the `connection` event.
+     */
+    _onConnection(socket) {
+        const ls = this.ls;
+        const es = this.esFactory();
+        const noiseState = new noise_state_1.NoiseState({ ls, es });
+        const noiseSocket = new noise_socket_1.NoiseSocket({ socket, noiseState });
+        this.emit('connection', noiseSocket);
+    }
+    /**
+     * Returns the address the server is listeening on. If the server is
+     * not listening, it will return undefined.
+     */
+    address() {
+        return this._server.address();
+    }
+    /**
+     * Stops the server from accepting new connections and keeps existing connections open.
+     * This function is asynchronous, the server is fully closed when all connections are
+     * ended and the server emits a `close` event. The optional `cb` event will be called
+     * once the `close` event occurs.
+     */
+    close(cb) {
+        this._server.close(cb);
+    }
+    /**
+     * Asynchronously get the number of concurrent connections on the server. Works when sockets were sent to forks.
+     */
+    getConnections(cb) {
+        this._server.getConnections(cb);
+    }
+    /**
+     * Start a server listening for connections. This method is asyncrhonous,
+     * once the server has started listening, the `listening` event will be
+     * emitted.
+     * @param callback Called when the server is listening. Automatically binds
+     * the function to the `listening` event.
+     */
+    listen(opts, callback) {
+        this._server.listen(opts, callback);
+        return this;
+    }
+    /**
+     * Indicates whether or not the server is listening for connections.
+     */
+    get listening() {
+        return this._server.listening;
+    }
+    /**
+     * Set this property to reject connections when the server's connection count gets high.
+     */
+    get maxConnections() {
+        return this._server.maxConnections;
+    }
+    set maxConnections(val) {
+        this._server.maxConnections = val;
+    }
+}
+exports.NoiseServer = NoiseServer;
+//# sourceMappingURL=noise-server.js.map

package/.yalc/@node-dlc/noise/dist/noise-server.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"noise-server.js","sourceRoot":"","sources":["../lib/noise-server.ts"],"names":[],"mappings":"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"}

package/.yalc/@node-dlc/noise/dist/noise-socket-options.d.ts

@@ -0,0 +1,28 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { ILogger } from '@node-dlc/logger';
+import { Socket } from 'net';
+import { NoiseState } from './noise-state';
+export type NoiseSocketOptions = {
+    /**
+     * Standard TCP Socket from the net module that will be wrapped
+     */
+    socket: Socket;
+    /**
+     * State machine for noise connections that is injected into the socket
+     */
+    noiseState: NoiseState;
+    /**
+     * Remote public key when connecting to a remote server. When provided,
+     * makes the socket the noise state initiator.
+     */
+    rpk?: Buffer;
+    /**
+     * Logger that can be optionally used by the noise system
+     */
+    logger?: ILogger;
+    /**
+     * High watermark for the stream
+     */
+    highWaterMark?: number;
+};

package/.yalc/@node-dlc/noise/dist/noise-socket-options.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=noise-socket-options.js.map

package/.yalc/@node-dlc/noise/dist/noise-socket-options.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"noise-socket-options.js","sourceRoot":"","sources":["../lib/noise-socket-options.ts"],"names":[],"mappings":""}

package/.yalc/@node-dlc/noise/dist/noise-socket.d.ts

@@ -0,0 +1,98 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { ILogger } from '@node-dlc/logger';
+import { Duplex } from 'stream';
+import { HANDSHAKE_STATE } from './handshake-state';
+import { NoiseSocketOptions } from './noise-socket-options';
+import { READ_STATE } from './read-state';
+export declare class NoiseSocket extends Duplex {
+    static READ_STATE: typeof READ_STATE;
+    static HANDSHAKE_STATE: typeof HANDSHAKE_STATE;
+    /**
+     * Remote public key as a 33-byte compressed public key for
+     * elliptic curve secp256k1
+     */
+    rpk: Buffer;
+    /**
+     * Indicates if the socket was the connection initiator
+     * which will determine how the handshake happens.
+     */
+    initiator: boolean;
+    /**
+     * Count of messages received by the socket.
+     */
+    messagesReceived: number;
+    /**
+     * A logger instance
+     */
+    logger: ILogger;
+    /**
+     * Controls the handshake process at the start of the connection.
+     * The socket is not readable until the handshake has been performed.
+     */
+    private _handshakeState;
+    /**
+     * Controls how reading and piping from the underlying TCP socket to
+     * the Duplex Streams read buffer works
+     */
+    private _readState;
+    /**
+     * Private property that maintains the handshakes and
+     * encrypts and decrypts messages while maintaining the
+     * proper key rotation scheme used defined in BOLT #8.
+     */
+    private _noiseState;
+    /**
+     * The wrapped socket
+     */
+    private _socket;
+    /**
+     * Message length state used for messages that may be split
+     * across multiple packets.
+     */
+    private _l;
+    /**
+     * NoiseSocket is a Duplex Stream that wraps a standard TCP Socket
+     * and layers in the BOLT #8 implementation of the Noise Protocol
+     * Framework.
+     *
+     * This socket can be used for any communication that wants to
+     * benefit from the security and privacy enhancing used by the
+     * Noise Protocol Framework.
+     */
+    constructor({ socket, noiseState, rpk, logger, highWaterMark, }: NoiseSocketOptions);
+    /**
+     * Half-closes the socket. It is still possible that the opposite
+     * side is still sending data.
+     */
+    end(): this;
+    /**
+     * Destroys the socket and ensures that no more I/O activity happens
+     * on the socket. When an `err` is included, an 'error' event will
+     * be emitted and all listeners will receive the error as an
+     * argument.
+     * @param err optional error to send
+     */
+    destroy(err?: Error): this;
+    /**
+     * Fires when the socket has connected. This method initiates the
+     * handshake and if there is a failure, terminates the connection.
+     */
+    private _onConnected;
+    /**
+     * _onData is triggered by the "readable" event on the
+     * underlying TCP socket. It is called each time there is new data
+     * received. It is responsible for reading data from the socket and
+     * performing the appropriate action given the current read state.
+     */
+    private _onData;
+    private _initiateHandshake;
+    private _processInitiator;
+    private _processInitiatorReply;
+    private _processResponderReply;
+    private _processPacketLength;
+    private _processPacketBody;
+    _read(): void;
+    _write(data: Buffer, encoding: string, cb: (err: Error) => void): void;
+    _final(): void;
+}