@atomicfinance/types 4.0.3 → 4.1.1

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

@@ -1,32 +0,0 @@
-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/lib/noise-socket.ts

@@ -1,381 +0,0 @@
-import { ILogger } from '@node-dlc/logger';
-import assert from 'assert';
-import { Socket } from 'net';
-import { Duplex } from 'stream';
-
-import { HANDSHAKE_STATE } from './handshake-state';
-import { NoiseError } from './noise-error';
-import { NoiseSocketOptions } from './noise-socket-options';
-import { NoiseState } from './noise-state';
-import { READ_STATE } from './read-state';
-
-export class NoiseSocket extends Duplex {
-  public static READ_STATE = READ_STATE;
-  public static HANDSHAKE_STATE = HANDSHAKE_STATE;
-
-  /**
-   * Remote public key as a 33-byte compressed public key for
-   * elliptic curve secp256k1
-   */
-  public rpk: Buffer;
-
-  /**
-   * Indicates if the socket was the connection initiator
-   * which will determine how the handshake happens.
-   */
-  public initiator: boolean;
-
-  /**
-   * Count of messages received by the socket.
-   */
-  public messagesReceived: number;
-
-  /**
-   * A logger instance
-   */
-  public 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: HANDSHAKE_STATE;
-
-  /**
-   * Controls how reading and piping from the underlying TCP socket to
-   * the Duplex Streams read buffer works
-   */
-  private _readState: READ_STATE;
-
-  /**
-   * 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: NoiseState;
-
-  /**
-   * The wrapped socket
-   */
-  private _socket: Socket;
-
-  /**
-   * Message length state used for messages that may be split
-   * across multiple packets.
-   */
-  private _l: number;
-
-  /**
-   * 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 = 2048,
-  }: NoiseSocketOptions) {
-    super({ objectMode: true, highWaterMark });
-    // perform type assertions
-    assert.ok(socket instanceof Socket, new NoiseError("socket argument must be an instance of Socket")); // prettier-ignore
-
-    this.rpk = rpk;
-
-    // if remote is provided, then we are the initiator
-    this.initiator = rpk !== undefined;
-
-    this._handshakeState = this.initiator
-      ? HANDSHAKE_STATE.INITIATOR_INITIATING
-      : HANDSHAKE_STATE.AWAITING_INITIATOR;
-
-    this._readState = READ_STATE.READY_FOR_LEN;
-
-    this._noiseState = noiseState;
-
-    this.messagesReceived = 0;
-
-    this._socket = socket;
-
-    this._socket.on('close', (hadError) => this.emit('close', hadError));
-    this._socket.on('connect', this._onConnected.bind(this));
-    this._socket.on('drain', () => this.emit('drain'));
-    this._socket.on('end', () => this.emit('end'));
-    this._socket.on('error', (err) => this.emit('error', err));
-    this._socket.on('lookup', (e, a, f, h) => this.emit('lookup', e, a, f, h));
-    this._socket.on('readable', this._onData.bind(this));
-    this._socket.on('timeout', () => this.emit('timeout'));
-
-    this.logger = logger;
-  }
-
-  /**
-   * Half-closes the socket. It is still possible that the opposite
-   * side is still sending data.
-   */
-  public end(): this {
-    this._socket.end();
-    return 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
-   */
-  public destroy(err?: Error): this {
-    this._socket.destroy(err);
-    return this;
-  }
-
-  /**
-   * Fires when the socket has connected. This method initiates the
-   * handshake and if there is a failure, terminates the connection.
-   */
-  private _onConnected() {
-    try {
-      if (this.initiator) {
-        this._initiateHandshake();
-      }
-    } catch (err) {
-      this.destroy(err);
-    }
-  }
-
-  /**
-   * _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() {
-    try {
-      // Loop while there was still data to process on the socket's
-      // buffer. This will stop when we don't have enough data or
-      // we encounter a back pressure issue;
-      let readMore = true;
-      do {
-        if (this._handshakeState !== HANDSHAKE_STATE.READY) {
-          switch (this._handshakeState) {
-            // Initiator received data before initialized
-            case HANDSHAKE_STATE.INITIATOR_INITIATING:
-              throw new NoiseError('Pending state is invalid');
-
-            // Responder Act1
-            case HANDSHAKE_STATE.AWAITING_INITIATOR:
-              readMore = this._processInitiator();
-              break;
-
-            // Responder Act3
-            case HANDSHAKE_STATE.AWAITING_INITIATOR_REPLY:
-              readMore = this._processInitiatorReply();
-              break;
-
-            // Initiator Act2
-            case HANDSHAKE_STATE.AWAITING_RESPONDER_REPLY:
-              readMore = this._processResponderReply();
-              break;
-          }
-        } else {
-          switch (this._readState) {
-            case READ_STATE.READY_FOR_LEN:
-              readMore = this._processPacketLength();
-              break;
-            case READ_STATE.READY_FOR_BODY:
-              readMore = this._processPacketBody();
-              break;
-            case READ_STATE.BLOCKED:
-              readMore = false;
-              break;
-            default:
-              throw new NoiseError('Unknown read state');
-          }
-        }
-      } while (readMore);
-    } catch (err) {
-      // Terminate on failures as we won't be able to recovery
-      // since the noise state has rotated nonce and we won't
-      // be able to any more data without additional errors.
-      this.destroy(err);
-    }
-  }
-
-  private _initiateHandshake() {
-    // create Initiator Act 1 message
-    const m = this._noiseState.initiatorAct1(this.rpk);
-
-    // send message to Responder
-    this._socket.write(m);
-
-    // transition state
-    this._handshakeState = HANDSHAKE_STATE.AWAITING_RESPONDER_REPLY;
-  }
-
-  private _processInitiator() {
-    // must read 50 bytes
-    let m = this._socket.read(50) as Buffer;
-    if (!m) return false;
-
-    // validate initiator act1 message
-    this._noiseState.receiveAct1(m);
-
-    // create reply message
-    m = this._noiseState.recieveAct2();
-
-    // send the reply
-    this._socket.write(m);
-
-    // transition
-    this._handshakeState = HANDSHAKE_STATE.AWAITING_INITIATOR_REPLY;
-
-    // indicate processing was successful
-    return true;
-  }
-
-  private _processInitiatorReply() {
-    // must read 66 bytes
-    const m = this._socket.read(66) as Buffer;
-    if (!m) return false;
-
-    // validate initiator act3 message
-    this._noiseState.receiveAct3(m);
-
-    // transition
-    this._handshakeState = HANDSHAKE_STATE.READY;
-
-    // capture the rpk since it is now available
-    this.rpk = this._noiseState.rpk;
-
-    // emit that we're ready!
-    this.emit('connect');
-    this.emit('ready');
-
-    // return true to continue processing
-    return true;
-  }
-
-  private _processResponderReply() {
-    // must read 50 bytes
-    let m = this._socket.read(50) as Buffer;
-    if (!m) return;
-
-    // process reply
-    this._noiseState.initiatorAct2(m);
-
-    // create final act of the handshake
-    m = this._noiseState.initiatorAct3();
-
-    // send final handshake
-    this._socket.write(m);
-
-    // transition
-    this._handshakeState = HANDSHAKE_STATE.READY;
-
-    // emit that we're ready!
-    this.emit('connect');
-    this.emit('ready');
-
-    // return true to continue processing
-    return true;
-  }
-
-  private _processPacketLength() {
-    const LEN_CIPHER_BYTES = 2;
-    const LEN_MAC_BYTES = 16;
-
-    // Try to read the length cipher bytes and the length MAC bytes
-    // If we cannot read the 18 bytes, the attempt to process the
-    // message will abort.
-    const lc = this._socket.read(LEN_CIPHER_BYTES + LEN_MAC_BYTES) as Buffer;
-    if (!lc) return;
-
-    // Decrypt the length including the MAC
-    const l = this._noiseState.decryptLength(lc);
-
-    // We need to store the value in a local variable in case
-    // we are unable to read the message body in its entirety.
-    // This allows us to skip the length read and prevents
-    // nonce issues since we've already decrypted the length.
-    this._l = l;
-
-    // Transition state
-    this._readState = READ_STATE.READY_FOR_BODY;
-
-    // return true to continue reading
-    return true;
-  }
-
-  private _processPacketBody() {
-    const MESSAGE_MAC_BYTES = 16;
-
-    // With the length, we can attempt to read the message plus
-    // the MAC for the message. If we are unable to read because
-    // there is not enough data in the read buffer, we need to
-    // store l. We are not able to simply unshift it becuase we
-    // have already rotated the keys.
-    const c = this._socket.read(this._l + MESSAGE_MAC_BYTES) as Buffer;
-    if (!c) return;
-
-    // Decrypt the full message cipher + MAC
-    const m = this._noiseState.decryptMessage(c);
-
-    // Now that we've read the message, we can remove the
-    // cached length before we transition states
-    this._l = null;
-
-    // Increment the number of messages received
-    this.messagesReceived++;
-
-    // Push the message onto the read buffer for the consumer to
-    // read. We are mindful of slow reads by the consumer and
-    // will respect backpressure signals.
-    const pushOk = this.push(m);
-    if (pushOk) {
-      this._readState = READ_STATE.READY_FOR_LEN;
-      return true;
-    } else {
-      if (this.logger) this.logger.debug('socket read is blocked');
-      this._readState = READ_STATE.BLOCKED;
-      return false;
-    }
-  }
-
-  // tslint:disable-next-line: member-ordering
-  public _read(): void {
-    if (this._handshakeState !== HANDSHAKE_STATE.READY) {
-      return;
-    }
-
-    if (this._readState === READ_STATE.BLOCKED) {
-      if (this.logger) this.logger.debug('socket read is unblocked');
-      this._readState = READ_STATE.READY_FOR_LEN;
-    }
-    // Trigger a read but wait until the end of the event loop.
-    // This is necessary when reading in paused mode where
-    // _read was triggered by stream.read() originating inside
-    // a "readable" event handler. Attempting to push more data
-    // synchronously will not trigger another "readable" event.
-    setImmediate(() => this._onData());
-  }
-
-  // tslint:disable-next-line: member-ordering
-  public _write(
-    data: Buffer,
-    encoding: string,
-    cb: (err: Error) => void,
-  ): void {
-    const c = this._noiseState.encryptMessage(data);
-    this._socket.write(c, cb);
-  }
-
-  public _final(): void {
-    //
-  }
-}

package/.yalc/@node-dlc/noise/lib/noise-state-options.ts

@@ -1,18 +0,0 @@
-import { ILogger } from '@node-dlc/logger';
-
-export type NoiseStateOptions = {
-  /**
-   * Local private key as a 32-byte buffer
-   */
-  ls: Buffer;
-
-  /**
-   * Ephemeral private key as a 32-byte
-   */
-  es: Buffer;
-
-  /**
-   * Logger to use for NoiseState
-   */
-  logger?: ILogger;
-};