@barchart/portfolio-client-js 9.0.0 → 10.0.0

package/lib/data/.meta.js

@@ -1,4 +1,5 @@
 const Currency = require('@barchart/common-js/lang/Currency'),
+	Day = require('@barchart/common-js/lang/Day'),
 	Decimal = require('@barchart/common-js/lang/Decimal'),
 	Timezones = require('@barchart/common-js/lang/Timezones');
 

package/lib/gateway/PortfolioGateway.js

@@ -510,70 +510,64 @@ module.exports = (() => {
 		 * connection has been established and other instance methods can be used.
 		 *
 		 * @public
+		 * @async
 		 * @param {JwtProvider} jwtProvider
 		 * @returns {Promise<PortfolioGateway>}
 		 */
-		connect(jwtProvider) {
-			return Promise.resolve()
-				.then(() => {
-					assert.argumentIsRequired(jwtProvider, 'jwtProvider', JwtProvider, 'JwtProvider');
+		async connect(jwtProvider) {
+			assert.argumentIsRequired(jwtProvider, 'jwtProvider', JwtProvider, 'JwtProvider');
 
-					if (this._startPromise === null) {
-						this._startPromise = Promise.resolve()
-							.then(() => {
-								this._started = true;
+			if (this._startPromise === null) {
+				this._startPromise = Promise.resolve()
+					.then(() => {
+						this._started = true;
 
-								this._jwtProvider = jwtProvider;
+						this._jwtProvider = jwtProvider;
 
-								return this;
-							}).catch((e) => {
-								this._started = false;
-								this._startPromise = null;
+						return this;
+					}).catch((e) => {
+						this._started = false;
+						this._startPromise = null;
 
-								this._jwtProvider = null;
+						this._jwtProvider = null;
 
-								throw e;
-							});
-					}
+						throw e;
+					});
+			}
 
-					return this._startPromise;
-				});
+			return this._startPromise;
 		}
 
 		/**
 		 * Creates a new portfolio for the current user.
 		 *
 		 * @public
+		 * @async
 		 * @param {Schema.PortfolioCreate} portfolio - Data regarding the portfolio to create.
 		 * @returns {Promise<Schema.Portfolio>}
 		 */
-		createPortfolio(portfolio) {
-			return Promise.resolve()
-				.then(() => {
-					checkStart.call(this);
+		async createPortfolio(portfolio) {
+			checkStart.call(this);
 
-					assert.argumentIsRequired(portfolio, 'portfolio', Object);
+			assert.argumentIsRequired(portfolio, 'portfolio', Object);
 
-					return Gateway.invoke(this._createPortfolioEndpoint, PortfolioSchema.CREATE.schema.format(portfolio));
-				});
+			return Gateway.invoke(this._createPortfolioEndpoint, PortfolioSchema.CREATE.schema.format(portfolio));
 		}
 
 		/**
 		 * Updates a portfolio.
 		 *
 		 * @public
+		 * @async
 		 * @param {Schema.PortfolioUpdate} portfolio
 		 * @returns {Promise<Schema.Portfolio>}
 		 */
-		updatePortfolio(portfolio) {
-			return Promise.resolve()
-				.then(() => {
-					checkStart.call(this);
+		async updatePortfolio(portfolio) {
+			checkStart.call(this);
 
-					assert.argumentIsRequired(portfolio, 'portfolio', Object);
+			assert.argumentIsRequired(portfolio, 'portfolio', Object);
 
-					return Gateway.invoke(this._updatePortfolioEndpoint, PortfolioSchema.UPDATE.schema.format(portfolio));
-				});
+			return Gateway.invoke(this._updatePortfolioEndpoint, PortfolioSchema.UPDATE.schema.format(portfolio));
 		}
 
 		/**
@@ -581,54 +575,48 @@ module.exports = (() => {
 		 * deleted (e.g. positions, transactions, etc).
 		 *
 		 * @public
+		 * @async
 		 * @param {String} portfolio - The identifier of the portfolio to delete.
 		 * @returns {Promise}
 		 */
-		deletePortfolio(portfolio) {
-			return Promise.resolve()
-				.then(() => {
-					checkStart.call(this);
+		async deletePortfolio(portfolio) {
+			checkStart.call(this);
 
-					assert.argumentIsRequired(portfolio, 'portfolio', String);
+			assert.argumentIsRequired(portfolio, 'portfolio', String);
 
-					return Gateway.invoke(this._deletePortfolioEndpoint, { portfolio: portfolio });
-				});
+			return Gateway.invoke(this._deletePortfolioEndpoint, { portfolio: portfolio });
 		}
 
 		/**
 		 * Reads all portfolios (or a single portfolio) for the current user.
 		 *
 		 * @public
+		 * @async
 		 * @param {String=} portfolio - A portfolio identifier. If omitted, all portfolios for the current user will be returned.
 		 * @returns {Promise<Schema.Portfolio[]>}
 		 */
-		readPortfolios(portfolio) {
-			return Promise.resolve()
-				.then(() => {
-					checkStart.call(this);
+		async readPortfolios(portfolio) {
+			checkStart.call(this);
 
-					assert.argumentIsOptional(portfolio, 'portfolio', String);
+			assert.argumentIsOptional(portfolio, 'portfolio', String);
 
-					return Gateway.invoke(this._readPortfoliosEndpoint, { portfolio: portfolio || '*' });
-				});
+			return Gateway.invoke(this._readPortfoliosEndpoint, { portfolio: portfolio || '*' });
 		}
 
 		/**
 		 * Updates a position.
 		 *
 		 * @public
+		 * @async
 		 * @param {Schema.PositionUpdate} position
 		 * @returns {Promise<Schema.Position>}
 		 */
-		updatePosition(position) {
-			return Promise.resolve()
-				.then(() => {
-					checkStart.call(this);
+		async updatePosition(position) {
+			checkStart.call(this);
 
-					assert.argumentIsRequired(position, 'position', Object);
+			assert.argumentIsRequired(position, 'position', Object);
 
-					return Gateway.invoke(this._updatePositionEndpoint, PositionSchema.UPDATE.schema.format(position));
-				});
+			return Gateway.invoke(this._updatePositionEndpoint, PositionSchema.UPDATE.schema.format(position));
 		}
 
 		/**
@@ -637,76 +625,69 @@ module.exports = (() => {
 		 * may cause other positions to be be deleted — for example, a position which was spun-off).
 		 *
 		 * @public
+		 * @async
 		 * @param {String} portfolio - The identifier of the portfolio which contains the position to delete.
 		 * @param {String} position - The identifier of the position to delete.
 		 * @returns {Promise<Schema.Position[]>}
 		 */
-		deletePosition(portfolio, position) {
-			return Promise.resolve()
-				.then(() => {
-					checkStart.call(this);
+		async deletePosition(portfolio, position) {
+			checkStart.call(this);
 
-					assert.argumentIsRequired(portfolio, 'portfolio', String);
-					assert.argumentIsRequired(position, 'position', String);
+			assert.argumentIsRequired(portfolio, 'portfolio', String);
+			assert.argumentIsRequired(position, 'position', String);
 
-					return Gateway.invoke(this._deletePositionEndpoint, { portfolio: portfolio, position: position });
-				});
+			return Gateway.invoke(this._deletePositionEndpoint, { portfolio: portfolio, position: position });
 		}
 
-
 		/**
 		 * Retrieves all positions for a user, a user's portfolio, or a single position.
 		 *
 		 * @public
+		 * @async
 		 * @param {String=} portfolio - The identifier of the portfolio containing the desired positions. If omitted, all positions for the current user, regardless of portfolio, will be returned.
 		 * @param {String=} position - The identifier of the specific position to read. If included, the "portfolio" parameter must be specified.
 		 * @param {Boolean=} includePreviousPrice
 		 * @returns {Promise<Schema.Position[]>}
 		 */
-		readPositions(portfolio, position, includePreviousPrice) {
-			return Promise.resolve()
-				.then(() => {
-					checkStart.call(this);
+		async readPositions(portfolio, position, includePreviousPrice) {
+			checkStart.call(this);
 
-					assert.argumentIsOptional(portfolio, 'portfolio', String);
-					assert.argumentIsOptional(position, 'position', String);
-					assert.argumentIsOptional(includePreviousPrice, 'includePreviousPrice', Boolean);
+			assert.argumentIsOptional(portfolio, 'portfolio', String);
+			assert.argumentIsOptional(position, 'position', String);
+			assert.argumentIsOptional(includePreviousPrice, 'includePreviousPrice', Boolean);
 
-					return Gateway.invoke(this._readPositionsEndpoint, { portfolio: portfolio || '*', position: position || '*', includePreviousPrice: includePreviousPrice || false });
-				});
+			return Gateway.invoke(this._readPositionsEndpoint, { portfolio: portfolio || '*', position: position || '*', includePreviousPrice: includePreviousPrice || false });
 		}
 
 		/**
 		 * Queries positions.
 		 *
 		 * @public
+		 * @async
 		 * @ignore
 		 * @param {String} symbol
 		 * @param {Boolean=} open
 		 * @param {PositionSchema=} schema
 		 * @returns {Promise<Schema.Position[]>}
 		 */
-		queryPositionsForSymbol(symbol, open, schema) {
-			return Promise.resolve()
-				.then(() => {
-					checkStart.call(this);
+		async queryPositionsForSymbol(symbol, open, schema) {
+			checkStart.call(this);
 
-					assert.argumentIsRequired(symbol, 'symbol', String);
-					assert.argumentIsOptional(open, 'open', Boolean);
+			assert.argumentIsRequired(symbol, 'symbol', String);
+			assert.argumentIsOptional(open, 'open', Boolean);
 
-					const payload = { };
+			const payload = { };
 
-					payload.portfolio = '*';
-					payload.position = '*';
+			payload.portfolio = '*';
+			payload.position = '*';
 
-					payload.symbol = symbol;
+			payload.symbol = symbol;
 
-					if (open) {
-						payload.open = open;
-					}
+			if (open) {
+				payload.open = open;
+			}
 
-					return Gateway.invoke(this._readPositionsEndpoint, payload);
-				});
+			return Gateway.invoke(this._readPositionsEndpoint, payload);
 		}
 
 		/**
@@ -714,12 +695,13 @@ module.exports = (() => {
 		 * changes to false.
 		 *
 		 * @public
+		 * @async
 		 * @ignore
 		 * @param {String} portfolio
 		 * @param {String} position
 		 * @returns {Promise}
 		 */
-		observePositionLock(portfolio, position) {
+		async observePositionLock(portfolio, position) {
 			return promise.build((resolveCallback) => {
 				assert.argumentIsRequired(portfolio, 'portfolio', String);
 				assert.argumentIsRequired(position, 'position', String);
@@ -753,6 +735,7 @@ module.exports = (() => {
 		 * Retrieves summaries for a user, a user's portfolio, or a single position.
 		 *
 		 * @public
+		 * @async
 		 * @ignore
 		 * @param {String=} portfolio
 		 * @param {String=} position
@@ -761,101 +744,96 @@ module.exports = (() => {
 		 * @param {Day=|String=} start
 		 * @returns {Promise<Schema.Position[]>}
 		 */
-		readPositionSummaries(portfolio, position, frames, periods, start) {
-			return Promise.resolve()
-				.then(() => {
-					checkStart.call(this);
-
-					assert.argumentIsOptional(portfolio, 'portfolio', String);
-					assert.argumentIsOptional(position, 'position', String);
-
-					if (is.array(frames)) {
-						if (frames.length > 0 && is.string(frames[ 0 ])) {
-							assert.argumentIsArray(frames, 'frames', String);
-						} else {
-							assert.argumentIsArray(frames, 'frames', PositionSummaryFrame, 'PositionSummaryFrame');
-						}
-					} else {
-						if (is.string(frames)) {
-							assert.argumentIsOptional(frames, 'frames', String);
-						} else {
-							assert.argumentIsOptional(frames, 'frames', PositionSummaryFrame, 'PositionSummaryFrame');
-						}
-					}
+		async readPositionSummaries(portfolio, position, frames, periods, start) {
+			checkStart.call(this);
+
+			assert.argumentIsOptional(portfolio, 'portfolio', String);
+			assert.argumentIsOptional(position, 'position', String);
+
+			if (is.array(frames)) {
+				if (frames.length > 0 && is.string(frames[ 0 ])) {
+					assert.argumentIsArray(frames, 'frames', String);
+				} else {
+					assert.argumentIsArray(frames, 'frames', PositionSummaryFrame, 'PositionSummaryFrame');
+				}
+			} else {
+				if (is.string(frames)) {
+					assert.argumentIsOptional(frames, 'frames', String);
+				} else {
+					assert.argumentIsOptional(frames, 'frames', PositionSummaryFrame, 'PositionSummaryFrame');
+				}
+			}
 
-					assert.argumentIsOptional(periods, 'periods', Number);
-					assert.argumentIsOptional(start, 'start', Day);
+			assert.argumentIsOptional(periods, 'periods', Number);
+			assert.argumentIsOptional(start, 'start', Day);
 
-					const payload = {
-						portfolio: portfolio || '*',
-						position: position || '*'
-					};
+			const payload = {
+				portfolio: portfolio || '*',
+				position: position || '*'
+			};
 
-					if (frames) {
-						payload.frames = frames.map((frame) => {
-							if (is.string(frame)) {
-								return Enum.fromCode(PositionSummaryFrame, frame);
-							} else {
-								return frame;
-							}
-						});
+			if (frames) {
+				payload.frames = frames.map((frame) => {
+					if (is.string(frame)) {
+						return Enum.fromCode(PositionSummaryFrame, frame);
+					} else {
+						return frame;
 					}
+				});
+			}
 
-					if (periods) {
-						payload.periods = periods;
-					}
+			if (periods) {
+				payload.periods = periods;
+			}
 
-					if (start) {
-						let s;
+			if (start) {
+				let s;
 
-						if (is.string(start)) {
-							s = Day.parse(start);
-						} else {
-							s = start;
-						}
+				if (is.string(start)) {
+					s = Day.parse(start);
+				} else {
+					s = start;
+				}
 
-						payload.start = s;
-					}
+				payload.start = s;
+			}
 
-					return Gateway.invoke(this._readPositionSummariesEndpoint, payload);
-				});
+			return Gateway.invoke(this._readPositionSummariesEndpoint, payload);
 		}
 
 		/**
 		 * Retrieves end-of-day valuations for the entire portfolio (or a single position).
 		 *
 		 * @public
+		 * @async
 		 * @ignore
 		 * @param {String} portfolio - The identifier of the portfolio.
 		 * @param {String=} position - The identifier of the position. If omitted, that valuation history will be returned for the entire portfolio (i.e. sum of valuations for all positions contained in the portfolio).
 		 * @param {Boolean=} parse - If true, the result will be a {@link Schema.ValuationContainer} object. Otherwise, the result will be a JSON-formatted string.
 		 * @returns {Promise<String|Schema.ValuationContainer>}
 		 */
-		readPositionValuations(portfolio, position, parse) {
-			return Promise.resolve()
-				.then(() => {
-					checkStart.call(this);
+		async readPositionValuations(portfolio, position, parse) {
+			checkStart.call(this);
 
-					assert.argumentIsRequired(portfolio, 'portfolio', String);
-					assert.argumentIsOptional(position, 'position', String);
+			assert.argumentIsRequired(portfolio, 'portfolio', String);
+			assert.argumentIsOptional(position, 'position', String);
 
-					const payload = { };
+			const payload = { };
 
-					payload.portfolio = portfolio;
-					payload.position = position || '*';
+			payload.portfolio = portfolio;
+			payload.position = position || '*';
 
-					return Gateway.invoke(this._readPositionValuationsEndpoint, payload)
-						.then((json) => {
-							let result;
+			return Gateway.invoke(this._readPositionValuationsEndpoint, payload)
+				.then((json) => {
+					let result;
 
-							if (parse) {
-								result = JSON.parse(json);
-							} else {
-								result = json;
-							}
+					if (parse) {
+						result = JSON.parse(json);
+					} else {
+						result = json;
+					}
 
-							return result;
-						});
+					return result;
 				});
 		}
 
@@ -863,131 +841,118 @@ module.exports = (() => {
 		 * Retrieves values availability of the portfolio and it's positions.
 		 *
 		 * @public
+		 * @async
 		 * @ignore
 		 * @param {String} portfolio
 		 * @return {Promise<Schema.ValuationsAvailabilityResult>}
 		 */
-		readPositionValuationsAvailability(portfolio) {
-			return Promise.resolve()
-				.then(() => {
-					checkStart.call(this);
+		async readPositionValuationsAvailability(portfolio) {
+			checkStart.call(this);
 
-					assert.argumentIsRequired(portfolio, 'portfolio', String);
+			assert.argumentIsRequired(portfolio, 'portfolio', String);
 
-					const payload = { };
-
-					payload.portfolio = portfolio;
-
-					return Gateway.invoke(this._readPositionValuationsAvailabilityEndpoint, payload);
-				});
+			return Gateway.invoke(this._readPositionValuationsAvailabilityEndpoint, { portfolio });
 		}
 
 		/**
 		 * Queries end-of-day position valuations across all user portfolios.
 		 *
 		 * @public
+		 * @async
 		 * @ignore
 		 * @param {String} symbol
 		 * @return {Promise<Object[]>}
 		 */
-		queryPositionValuations(symbol) {
-			return Promise.resolve()
-				.then(() => {
-					assert.argumentIsRequired(symbol, 'symbol', String);
+		async queryPositionValuations(symbol) {
+			assert.argumentIsRequired(symbol, 'symbol', String);
 
-					return Gateway.invoke(this._queryPositionValuationsEndpoint, { symbol });
-				});
+			return Gateway.invoke(this._queryPositionValuationsEndpoint, { symbol });
 		}
 
 		/**
 		 * Creates a new transaction.
 		 *
 		 * @public
+		 * @async
 		 * @param {Schema.TransactionCreate} transaction
 		 * @param {Object=} options
 		 * @returns {Promise<Schema.TransactionMutateResult>}
 		 */
-		createTransaction(transaction, options) {
-			return Promise.resolve()
-				.then(() => {
-					checkStart.call(this);
-
-					assert.argumentIsRequired(transaction, 'transaction', Object);
-					assert.argumentIsRequired(transaction.portfolio, 'transaction.portfolio', String);
-					assert.argumentIsOptional(transaction.position, 'transaction.position', String);
-					assert.argumentIsOptional(options, 'options', Object);
-
-					if (!transaction.position) {
-						transaction.position = 'new';
-					}
+		async createTransaction(transaction, options) {
+			checkStart.call(this);
+
+			assert.argumentIsRequired(transaction, 'transaction', Object);
+			assert.argumentIsRequired(transaction.portfolio, 'transaction.portfolio', String);
+			assert.argumentIsOptional(transaction.position, 'transaction.position', String);
+			assert.argumentIsOptional(options, 'options', Object);
 
-					const schema = getTransactionSchema(transaction);
+			if (!transaction.position) {
+				transaction.position = 'new';
+			}
 
-					const payload = { };
+			const schema = getTransactionSchema(transaction);
 
-					payload.transaction = schema.schema.format(transaction);
-					payload.options = options || { };
+			const payload = { };
 
-					return Gateway.invoke(this._createTransactionEndpoint, payload);
-				});
+			payload.transaction = schema.schema.format(transaction);
+			payload.options = options || { };
+
+			return Gateway.invoke(this._createTransactionEndpoint, payload);
 		}
 
 		/**
 		 * Edits a transaction (e.g. change the date, price, quantity, etc).
 		 *
 		 * @public
+		 * @async
 		 * @param {Schema.Transaction} transaction
 		 * @returns {Promise<Schema.TransactionMutateResult>}
 		 */
-		editTransaction(transaction) {
-			return Promise.resolve()
-				.then(() => {
-					checkStart.call(this);
+		async editTransaction(transaction) {
+			checkStart.call(this);
 
-					assert.argumentIsRequired(transaction, 'transaction', Object);
-					assert.argumentIsRequired(transaction.portfolio, 'transaction.portfolio', String);
-					assert.argumentIsRequired(transaction.position, 'transaction.position', String);
-					assert.argumentIsRequired(transaction.sequence, 'transaction.sequence', Number);
+			assert.argumentIsRequired(transaction, 'transaction', Object);
+			assert.argumentIsRequired(transaction.portfolio, 'transaction.portfolio', String);
+			assert.argumentIsRequired(transaction.position, 'transaction.position', String);
+			assert.argumentIsRequired(transaction.sequence, 'transaction.sequence', Number);
 
-					const schema = getTransactionSchema(transaction);
+			const schema = getTransactionSchema(transaction);
 
-					return Gateway.invoke(this._editTransactionEndpoint, schema.schema.format(transaction));
-				});
+			return Gateway.invoke(this._editTransactionEndpoint, schema.schema.format(transaction));
 		}
 
 		/**
 		 * Switch the reinvestment strategy for a single transaction.
 		 *
 		 * @public
+		 * @async
 		 * @ignore
 		 * @param {Schema.Transaction} transaction
 		 * @param {TransactionType} type
 		 * @returns {Promise<Schema.TransactionMutateResult>}
 		 */
-		switchTransaction(transaction, type) {
-			return Promise.resolve()
-				.then(() => {
-					checkStart.call(this);
+		async switchTransaction(transaction, type) {
+			checkStart.call(this);
 
-					assert.argumentIsRequired(transaction, 'transaction', Object);
-					assert.argumentIsRequired(transaction.portfolio, 'transaction.portfolio', String);
-					assert.argumentIsRequired(transaction.position, 'transaction.position', String);
-					assert.argumentIsRequired(transaction.sequence, 'transaction.sequence', Number);
-					assert.argumentIsRequired(type, type, TransactionType, 'TransactionType');
+			assert.argumentIsRequired(transaction, 'transaction', Object);
+			assert.argumentIsRequired(transaction.portfolio, 'transaction.portfolio', String);
+			assert.argumentIsRequired(transaction.position, 'transaction.position', String);
+			assert.argumentIsRequired(transaction.sequence, 'transaction.sequence', Number);
+			assert.argumentIsRequired(type, type, TransactionType, 'TransactionType');
 
-					const schema = getTransactionSchema(transaction);
-					const payload = schema.schema.format(transaction);
+			const schema = getTransactionSchema(transaction);
+			const payload = schema.schema.format(transaction);
 
-					payload.switch = type;
+			payload.switch = type;
 
-					return Gateway.invoke(this._switchTransactionEndpoint, payload);
-				});
+			return Gateway.invoke(this._switchTransactionEndpoint, payload);
 		}
 
 		/**
 		 * Deletes a transaction.
 		 *
 		 * @public
+		 * @async
 		 * @param {String} portfolio - The identifier of the portfolio which contains the targeted position.
 		 * @param {String} position - The identifier of the targeted position.
 		 * @param {Number} sequence - The sequence number of the transaction to delete.
@@ -996,57 +961,52 @@ module.exports = (() => {
 		 * @param {Day=} echoEnd
 		 * @returns {Promise<Schema.TransactionMutateResult>}
 		 */
-		deleteTransaction(portfolio, position, sequence, force, echoStart, echoEnd) {
-			return Promise.resolve()
-				.then(() => {
-					checkStart.call(this);
-
-					assert.argumentIsRequired(portfolio, 'portfolio', String);
-					assert.argumentIsRequired(position, 'position', String);
-					assert.argumentIsRequired(sequence, 'sequence', Number);
-					assert.argumentIsOptional(force, 'force', Boolean);
-					assert.argumentIsOptional(echoStart, 'echoStart', Day, 'Day');
-					assert.argumentIsOptional(echoEnd, 'echoEnd', Day, 'Day');
-
-					let payload = { };
-
-					payload.portfolio = portfolio;
-					payload.position = position;
-					payload.sequence = sequence;
-					payload.force = is.boolean(force) && force;
-
-					if (echoStart) {
-						payload.echoStart = echoStart;
-					}
+		async deleteTransaction(portfolio, position, sequence, force, echoStart, echoEnd) {
+			checkStart.call(this);
 
-					if (echoEnd) {
-						payload.echoEnd = echoEnd;
-					}
+			assert.argumentIsRequired(portfolio, 'portfolio', String);
+			assert.argumentIsRequired(position, 'position', String);
+			assert.argumentIsRequired(sequence, 'sequence', Number);
+			assert.argumentIsOptional(force, 'force', Boolean);
+			assert.argumentIsOptional(echoStart, 'echoStart', Day, 'Day');
+			assert.argumentIsOptional(echoEnd, 'echoEnd', Day, 'Day');
 
-					return Gateway.invoke(this._deleteTransactionEndpoint, payload);
-				});
+			let payload = { };
+
+			payload.portfolio = portfolio;
+			payload.position = position;
+			payload.sequence = sequence;
+			payload.force = is.boolean(force) && force;
+
+			if (echoStart) {
+				payload.echoStart = echoStart;
+			}
+
+			if (echoEnd) {
+				payload.echoEnd = echoEnd;
+			}
+
+			return Gateway.invoke(this._deleteTransactionEndpoint, payload);
 		}
 
 		/**
 		 * Retrieves transactions for a portfolio, or a single position.
 		 *
 		 * @public
+		 * @async
 		 * @param {String} portfolio - The identifier of the portfolio containing the desired transactions.
 		 * @param {String=} position - The identifier for the position to read transactions for. If included, the resulting transactions will be limited to the specified position. Otherwise, transactions for all positions in the portfolio, will be returned.
 		 * @param {Number=} sequence - The sequence number of the specific transaction to read. If included, both the "portfolio" and "position" parameters must be specified.
 		 * @returns {Promise<Schema.Transaction[]>}
 		 */
-		readTransactions(portfolio, position, sequence) {
-			return Promise.resolve()
-				.then(() => {
-					checkStart.call(this);
+		async readTransactions(portfolio, position, sequence) {
+			checkStart.call(this);
 
-					assert.argumentIsRequired(portfolio, 'portfolio', String);
-					assert.argumentIsOptional(position, 'position', String);
-					assert.argumentIsOptional(sequence, 'sequence', Number);
+			assert.argumentIsRequired(portfolio, 'portfolio', String);
+			assert.argumentIsOptional(position, 'position', String);
+			assert.argumentIsOptional(sequence, 'sequence', Number);
 
-					return Gateway.invoke(this._readTransactionsEndpoint, { portfolio: portfolio, position: position || '*', sequence: is.number(sequence) ? sequence.toString() : '*' });
-				});
+			return Gateway.invoke(this._readTransactionsEndpoint, { portfolio: portfolio, position: position || '*', sequence: is.number(sequence) ? sequence.toString() : '*' });
 		}
 
 		/**
@@ -1054,6 +1014,7 @@ module.exports = (() => {
 		 * for a portfolio, or a single position.
 		 *
 		 * @public
+		 * @async
 		 * @ignore
 		 * @param {String} portfolio
 		 * @param {String=} position
@@ -1062,40 +1023,38 @@ module.exports = (() => {
 		 * @param {Boolean=} descending
 		 * @returns {Promise<Object[]>}
 		 */
-		readTransactionsFormatted(portfolio, position, startDay, endDay, descending) {
-			return Promise.resolve()
-				.then(() => {
-					checkStart.call(this);
+		async readTransactionsFormatted(portfolio, position, startDay, endDay, descending) {
+			checkStart.call(this);
 
-					assert.argumentIsRequired(portfolio, 'portfolio', String);
-					assert.argumentIsOptional(position, 'position', String);
-					assert.argumentIsOptional(startDay, 'startDay', Day, 'Day');
-					assert.argumentIsOptional(endDay, 'endDay', Day, 'Day');
-					assert.argumentIsOptional(descending, 'descending', Boolean);
+			assert.argumentIsRequired(portfolio, 'portfolio', String);
+			assert.argumentIsOptional(position, 'position', String);
+			assert.argumentIsOptional(startDay, 'startDay', Day, 'Day');
+			assert.argumentIsOptional(endDay, 'endDay', Day, 'Day');
+			assert.argumentIsOptional(descending, 'descending', Boolean);
 
-					const payload = { };
+			const payload = { };
 
-					payload.portfolio = portfolio;
-					payload.position = position || '*';
+			payload.portfolio = portfolio;
+			payload.position = position || '*';
 
-					if (startDay) {
-						payload.start = startDay;
-					}
+			if (startDay) {
+				payload.start = startDay;
+			}
 
-					if (endDay) {
-						payload.end = endDay;
-					}
+			if (endDay) {
+				payload.end = endDay;
+			}
 
-					payload.descending = is.boolean(descending) && descending;
+			payload.descending = is.boolean(descending) && descending;
 
-					return Gateway.invoke(this._readTransactionsReportEndpoint, payload);
-				});
+			return Gateway.invoke(this._readTransactionsReportEndpoint, payload);
 		}
 
 		/**
 		 * Reads a single page of formatted transactions.
 		 *
 		 * @public
+		 * @async
 		 * @ignore
 		 * @param {String} portfolio
 		 * @param {String} position
@@ -1104,47 +1063,45 @@ module.exports = (() => {
 		 * @param {Boolean=} descending
 		 * @returns {Promise<Object[]>}
 		 */
-		readTransactionsFormattedPage(portfolio, position, sequence, count, descending) {
-			return Promise.resolve()
-				.then(() => {
-					checkStart.call(this);
+		async readTransactionsFormattedPage(portfolio, position, sequence, count, descending) {
+			checkStart.call(this);
 
-					assert.argumentIsRequired(portfolio, 'portfolio', String);
-					assert.argumentIsRequired(position, 'position', String);
-					assert.argumentIsOptional(sequence, 'sequence', Number);
-					assert.argumentIsOptional(count, 'count', Number);
-					assert.argumentIsOptional(descending, 'descending', Boolean);
+			assert.argumentIsRequired(portfolio, 'portfolio', String);
+			assert.argumentIsRequired(position, 'position', String);
+			assert.argumentIsOptional(sequence, 'sequence', Number);
+			assert.argumentIsOptional(count, 'count', Number);
+			assert.argumentIsOptional(descending, 'descending', Boolean);
 
-					const payload = { };
+			const payload = { };
 
-					payload.portfolio = portfolio;
-					payload.position = position;
+			payload.portfolio = portfolio;
+			payload.position = position;
 
-					payload.page = true;
+			payload.page = true;
 
-					if (sequence) {
-						payload.sequence = sequence;
-					}
+			if (sequence) {
+				payload.sequence = sequence;
+			}
 
-					if (count) {
-						payload.count = count;
-					}
+			if (count) {
+				payload.count = count;
+			}
 
-					payload.descending = is.boolean(descending) && descending;
+			payload.descending = is.boolean(descending) && descending;
 
-					return Gateway.invoke(this._readTransactionsReportEndpoint, payload);
-				});
+			return Gateway.invoke(this._readTransactionsReportEndpoint, payload);
 		}
 
 		/**
 		 * Retrieves end-of-day valuations for the entire portfolio (or a single position).
 		 *
 		 * @public
+		 * @async
 		 * @param {String} portfolio - The identifier of the portfolio.
 		 * @param {String=} position - The identifier of the position. If omitted, that valuation history will be returned for the entire portfolio (i.e. sum of valuations for all positions contained in the portfolio).
 		 * @returns {Promise<Schema.ValuationContainer>}
 		 */
-		readValuations(portfolio, position) {
+		async readValuations(portfolio, position) {
 			return this.readPositionValuations(portfolio, position, true);
 		}
 
@@ -1153,10 +1110,11 @@ module.exports = (() => {
 		 * within a portfolio.
 		 *
 		 * @public
+		 * @async
 		 * @param {String} portfolio - The identifier of the portfolio.
 		 * @returns {Promise<Schema.ValuationsAvailabilityResult>}
 		 */
-		checkValuations(portfolio) {
+		async checkValuations(portfolio) {
 			return this.readPositionValuationsAvailability(portfolio);
 		}
 
@@ -1164,26 +1122,21 @@ module.exports = (() => {
 		 * Returns all position summary definitions for a portfolio.
 		 *
 		 * @public
+		 * @async
 		 * @ignore
 		 * @param {String} portfolio
 		 */
-		readBrokerageReportAvailability(portfolio) {
-			return Promise.resolve()
-				.then(() => {
-					assert.argumentIsRequired(portfolio, 'portfolio', String);
-
-					const payload = { };
+		async readBrokerageReportAvailability(portfolio) {
+			assert.argumentIsRequired(portfolio, 'portfolio', String);
 
-					payload.portfolio = portfolio;
-
-					return Gateway.invoke(this._readBrokerageReportAvailabilityEndpoint, payload);
-				});
+			return Gateway.invoke(this._readBrokerageReportAvailabilityEndpoint, { portfolio });
 		}
 
 		/**
 		 * Generates a URL suitable for downloading a brokerage report (as a PDF).
 		 *
 		 * @public
+		 * @async
 		 * @ignore
 		 * @param {String} user
 		 * @param {String} portfolio
@@ -1191,31 +1144,26 @@ module.exports = (() => {
 		 * @param {Day} end
 		 * @return {Promise<String>}
 		 */
-		getBrokerageReportUrl(user, portfolio, frame, end) {
-			return Promise.resolve()
-				.then(() => {
-					checkStart.call(this);
+		async getBrokerageReportUrl(user, portfolio, frame, end) {
+			checkStart.call(this);
 
-					assert.argumentIsRequired(user, 'user', String);
-					assert.argumentIsRequired(portfolio, 'portfolio', String);
-					assert.argumentIsRequired(frame, 'frame', PositionSummaryFrame, 'PositionSummaryFrame');
-					assert.argumentIsRequired(end, 'end', Day, 'Day');
+			assert.argumentIsRequired(user, 'user', String);
+			assert.argumentIsRequired(portfolio, 'portfolio', String);
+			assert.argumentIsRequired(frame, 'frame', PositionSummaryFrame, 'PositionSummaryFrame');
+			assert.argumentIsRequired(end, 'end', Day, 'Day');
 
-					return this._brokerageReportUrlGenerator(user, portfolio, frame, end);
-				});
+			return this._brokerageReportUrlGenerator(user, portfolio, frame, end);
 		}
 
 		/**
 		 * Returns current version of the Portfolio Service.
 		 *
 		 * @public
+		 * @async
 		 * @returns {Promise<Object>}
 		 */
-		readVersion() {
-			return Promise.resolve()
-				.then(() => {
-					return Gateway.invoke(this._readVersionEndpoint);
-				});
+		async readVersion() {
+			return Gateway.invoke(this._readVersionEndpoint);
 		}
 
 		/**
@@ -1248,78 +1196,70 @@ module.exports = (() => {
 		 *
 		 * @public
 		 * @static
+		 * @async
 		 * @param {JwtProvider} jwtProvider
 		 * @param {String=} product
 		 * @returns {Promise<PortfolioGateway>}
 		 */
-		static forTest(jwtProvider, product) {
-			return Promise.resolve()
-				.then(() => {
-					assert.argumentIsRequired(jwtProvider, 'jwtProvider', JwtProvider, 'JwtProvider');
-					assert.argumentIsOptional(product, 'product', String);
+		static async forTest(jwtProvider, product) {
+			assert.argumentIsRequired(jwtProvider, 'jwtProvider', JwtProvider, 'JwtProvider');
+			assert.argumentIsOptional(product, 'product', String);
 
-					return start(new PortfolioGateway(REST_API_SECURE_PROTOCOL, Configuration.testHost, REST_API_SECURE_PORT, 'test', product), jwtProvider);
-				});
+			return start(new PortfolioGateway(REST_API_SECURE_PROTOCOL, Configuration.testHost, REST_API_SECURE_PORT, 'test', product), jwtProvider);
 		}
 
 		/**
 		 * Creates and starts a new {@link PortfolioGateway} for use in the private development environment.
 		 *
 		 * @public
-		 * @ignore
 		 * @static
+		 * @async
+		 * @ignore
 		 * @param {JwtProvider} jwtProvider
 		 * @param {String=} product
 		 * @returns {Promise<PortfolioGateway>}
 		 */
-		static forDevelopment(jwtProvider, product) {
-			return Promise.resolve()
-				.then(() => {
-					assert.argumentIsRequired(jwtProvider, 'jwtProvider', JwtProvider, 'JwtProvider');
-					assert.argumentIsOptional(product, 'product', String);
+		static async forDevelopment(jwtProvider, product) {
+			assert.argumentIsRequired(jwtProvider, 'jwtProvider', JwtProvider, 'JwtProvider');
+			assert.argumentIsOptional(product, 'product', String);
 
-					return start(new PortfolioGateway(REST_API_SECURE_PROTOCOL, Configuration.developmentHost, REST_API_SECURE_PORT, 'development', product), jwtProvider);
-				});
+			return start(new PortfolioGateway(REST_API_SECURE_PROTOCOL, Configuration.developmentHost, REST_API_SECURE_PORT, 'development', product), jwtProvider);
 		}
 
 		/**
 		 * Creates and starts a new {@link PortfolioGateway} for use in the private staging environment.
 		 *
 		 * @public
-		 * @ignore
 		 * @static
+		 * @async
+		 * @ignore
 		 * @param {JwtProvider} jwtProvider
 		 * @param {String=} product
 		 * @returns {Promise<PortfolioGateway>}
 		 */
-		static forStaging(jwtProvider, product) {
-			return Promise.resolve()
-				.then(() => {
-					assert.argumentIsRequired(jwtProvider, 'jwtProvider', JwtProvider, 'JwtProvider');
-					assert.argumentIsOptional(product, 'product', String);
+		static async forStaging(jwtProvider, product) {
+			assert.argumentIsRequired(jwtProvider, 'jwtProvider', JwtProvider, 'JwtProvider');
+			assert.argumentIsOptional(product, 'product', String);
 
-					return start(new PortfolioGateway(REST_API_SECURE_PROTOCOL, Configuration.stagingHost, REST_API_SECURE_PORT, 'staging', product), jwtProvider);
-				});
+			return start(new PortfolioGateway(REST_API_SECURE_PROTOCOL, Configuration.stagingHost, REST_API_SECURE_PORT, 'staging', product), jwtProvider);
 		}
 
 		/**
 		 * Creates and starts a new {@link PortfolioGateway} for use in the private staging WWW environment.
 		 *
 		 * @public
-		 * @ignore
 		 * @static
+		 * @async
+		 * @ignore
 		 * @param {JwtProvider} jwtProvider
 		 * @param {String=} product
 		 * @returns {Promise<PortfolioGateway>}
 		 */
-		static forStagingWww(jwtProvider, product) {
-			return Promise.resolve()
-				.then(() => {
-					assert.argumentIsRequired(jwtProvider, 'jwtProvider', JwtProvider, 'JwtProvider');
-					assert.argumentIsOptional(product, 'product', String);
+		static async forStagingWww(jwtProvider, product) {
+			assert.argumentIsRequired(jwtProvider, 'jwtProvider', JwtProvider, 'JwtProvider');
+			assert.argumentIsOptional(product, 'product', String);
 
-					return start(new PortfolioGateway(REST_API_SECURE_PROTOCOL, Configuration.stagingWwwHost, REST_API_SECURE_PORT, 'www-staging', product), jwtProvider);
-				});
+			return start(new PortfolioGateway(REST_API_SECURE_PROTOCOL, Configuration.stagingWwwHost, REST_API_SECURE_PORT, 'www-staging', product), jwtProvider);
 		}
 
 		/**
@@ -1327,18 +1267,16 @@ module.exports = (() => {
 		 *
 		 * @public
 		 * @static
+		 * @async
 		 * @param {JwtProvider} jwtProvider
 		 * @param {String=} product
 		 * @returns {Promise<PortfolioGateway>}
 		 */
-		static forDemo(jwtProvider, product) {
-			return Promise.resolve()
-				.then(() => {
-					assert.argumentIsRequired(jwtProvider, 'jwtProvider', JwtProvider, 'JwtProvider');
-					assert.argumentIsOptional(product, 'product', String);
+		static async forDemo(jwtProvider, product) {
+			assert.argumentIsRequired(jwtProvider, 'jwtProvider', JwtProvider, 'JwtProvider');
+			assert.argumentIsOptional(product, 'product', String);
 
-					return start(new PortfolioGateway(REST_API_SECURE_PROTOCOL, Configuration.demoHost, REST_API_SECURE_PORT, 'demo', product), jwtProvider);
-				});
+			return start(new PortfolioGateway(REST_API_SECURE_PROTOCOL, Configuration.demoHost, REST_API_SECURE_PORT, 'demo', product), jwtProvider);
 		}
 
 		/**
@@ -1346,18 +1284,16 @@ module.exports = (() => {
 		 *
 		 * @public
 		 * @static
+		 * @async
 		 * @param {JwtProvider} jwtProvider
 		 * @param {String=} product
 		 * @returns {Promise<PortfolioGateway>}
 		 */
-		static forProduction(jwtProvider, product) {
-			return Promise.resolve()
-				.then(() => {
-					assert.argumentIsRequired(jwtProvider, 'jwtProvider', JwtProvider, 'JwtProvider');
-					assert.argumentIsOptional(product, 'product', String);
+		static async forProduction(jwtProvider, product) {
+			assert.argumentIsRequired(jwtProvider, 'jwtProvider', JwtProvider, 'JwtProvider');
+			assert.argumentIsOptional(product, 'product', String);
 
-					return start(new PortfolioGateway(REST_API_SECURE_PROTOCOL, Configuration.productionHost, REST_API_SECURE_PORT, 'production', product), jwtProvider);
-				});
+			return start(new PortfolioGateway(REST_API_SECURE_PROTOCOL, Configuration.productionHost, REST_API_SECURE_PORT, 'production', product), jwtProvider);
 		}
 
 		/**
@@ -1370,34 +1306,29 @@ module.exports = (() => {
 		 * @param {String=} product
 		 * @returns {Promise<PortfolioGateway>}
 		 */
-		static forProductionWww(jwtProvider, product) {
-			return Promise.resolve()
-				.then(() => {
-					assert.argumentIsRequired(jwtProvider, 'jwtProvider', JwtProvider, 'JwtProvider');
-					assert.argumentIsOptional(product, 'product', String);
+		static async forProductionWww(jwtProvider, product) {
+			assert.argumentIsRequired(jwtProvider, 'jwtProvider', JwtProvider, 'JwtProvider');
+			assert.argumentIsOptional(product, 'product', String);
 
-					return start(new PortfolioGateway(REST_API_SECURE_PROTOCOL, Configuration.productionWwwHost, REST_API_SECURE_PORT, 'www-production', product), jwtProvider);
-				});
+			return start(new PortfolioGateway(REST_API_SECURE_PROTOCOL, Configuration.productionWwwHost, REST_API_SECURE_PORT, 'www-production', product), jwtProvider);
 		}
 
 		/**
 		 * Creates and starts a new {@link PortfolioGateway} for use in the private admin environment.
 		 *
 		 * @public
-		 * @ignore
 		 * @static
+		 * @async
+		 * @ignore
 		 * @param {JwtProvider} jwtProvider
 		 * @param {String=} product
 		 * @returns {Promise<PortfolioGateway>}
 		 */
-		static forAdmin(jwtProvider, product) {
-			return Promise.resolve()
-				.then(() => {
-					assert.argumentIsRequired(jwtProvider, 'jwtProvider', JwtProvider, 'JwtProvider');
-					assert.argumentIsOptional(product, 'product', String);
+		static async forAdmin(jwtProvider, product) {
+			assert.argumentIsRequired(jwtProvider, 'jwtProvider', JwtProvider, 'JwtProvider');
+			assert.argumentIsOptional(product, 'product', String);
 
-					return start(new PortfolioGateway(REST_API_SECURE_PROTOCOL, Configuration.adminHost, REST_API_SECURE_PORT, 'admin', product), jwtProvider);
-				});
+			return start(new PortfolioGateway(REST_API_SECURE_PROTOCOL, Configuration.adminHost, REST_API_SECURE_PORT, 'admin', product), jwtProvider);
 		}
 
 		_onDispose() {
@@ -1519,14 +1450,6 @@ module.exports = (() => {
 		}
 	});
 
-	const responseInterceptorForWealthscopeToken = ResponseInterceptor.fromDelegate((response, ignored) => {
-		try {
-			return JSON.parse(response.data).token;
-		} catch (e) {
-			console.error('Error deserializing data', e);
-		}
-	});
-
 	const responseInterceptorForDeserialization = ResponseInterceptor.fromDelegate((response, ignored) => {
 		try {
 			return JSON.parse(response.data);
@@ -1535,11 +1458,10 @@ module.exports = (() => {
 		}
 	});
 
-	function start(gateway, jwtProvider) {
-		return gateway.connect(jwtProvider)
-			.then(() => {
-				return gateway;
-			});
+	async function start(gateway, jwtProvider) {
+		await gateway.connect(jwtProvider);
+
+		return gateway;
 	}
 
 	function checkStart() {

package/lib/index.js

@@ -7,6 +7,6 @@ module.exports = (() => {
 	return {
 		JwtProvider: JwtProvider,
 		PortfolioGateway: PortfolioGateway,
-		version: '9.0.0'
+		version: '10.0.0'
 	};
 })();

package/lib/security/JwtProvider.js

@@ -55,36 +55,34 @@ module.exports = (() => {
 		 * Reads the current token, refreshing if necessary.
 		 *
 		 * @public
+		 * @async
 		 * @returns {Promise<String>}
 		 */
-		getToken() {
-			return Promise.resolve()
-				.then(() => {
-					if (this._refreshPending) {
-						return this._tokenPromise;
-					}
-
-					if (this._tokenPromise === null || this._refreshInterval === null || (this._refreshInterval > 0 && getTime() > (this._refreshTimestamp + this._refreshInterval + this._refreshJitter))) {
-						this._refreshPending = true;
-
-						this._tokenPromise = this._scheduler.backoff(() => this._tokenGenerator(), 100, 'Read JWT token', 3)
-							.then((token) => {
-								this._refreshTimestamp = getTime();
-								this._refreshPending = false;
-
-								return token;
-							}).catch((e) => {
-								this._tokenPromise = null;
-
-								this._refreshTimestamp = null;
-								this._refreshPending = false;
-
-								return Promise.reject(e);
-							});
-					}
-
-					return this._tokenPromise;
-				});
+		async getToken() {
+			if (this._refreshPending) {
+				return this._tokenPromise;
+			}
+
+			if (this._tokenPromise === null || this._refreshInterval === null || (this._refreshInterval > 0 && getTime() > (this._refreshTimestamp + this._refreshInterval + this._refreshJitter))) {
+				this._refreshPending = true;
+
+				this._tokenPromise = this._scheduler.backoff(() => this._tokenGenerator(), 100, 'Read JWT token', 3)
+					.then((token) => {
+						this._refreshTimestamp = getTime();
+						this._refreshPending = false;
+
+						return token;
+					}).catch((e) => {
+						this._tokenPromise = null;
+
+						this._refreshTimestamp = null;
+						this._refreshPending = false;
+
+						return Promise.reject(e);
+					});
+			}
+
+			return this._tokenPromise;
 		}
 
 		/**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@barchart/portfolio-client-js",
-  "version": "9.0.0",
+  "version": "10.0.0",
   "description": "JavaScript SDK for Barchart's Portfolio Service",
   "homepage": "https://docs.barchart.com/portfolio/#/",
   "author": {
@@ -29,7 +29,7 @@
   ],
   "dependencies": {
     "@barchart/common-js": "^4.58.0",
-    "@barchart/portfolio-api-common": "^6.0.0"
+    "@barchart/portfolio-api-common": "^7.0.0"
   },
   "devDependencies": {
     "@babel/core": "^7.11.1",