Align all param comments so that they are more readable

4 files changed, 99 insertions, 87 deletions

diff --git a/src/0x.js.ts b/src/0x.js.ts
index c04fd3728..b1e4e25ff 100644
--- a/src/0x.js.ts
+++ b/src/0x.js.ts
@@ -37,10 +37,10 @@ export class ZeroEx {
     /**
      * Verifies that the elliptic curve signature `signature` was generated
      * by signing `dataHex` with the private key corresponding to the `signerAddressHex` address.
-     * @param   dataHex The hex encoded data signed by the supplied signature.
-     * @param   signature A JS object containing the elliptic curve signature parameters.
+     * @param   dataHex          The hex encoded data signed by the supplied signature.
+     * @param   signature        A JS object containing the elliptic curve signature parameters.
      * @param   signerAddressHex The hex encoded address that signed the dataHex, producing the supplied signature.
-     * @return Whether the signature is valid for the supplied signerAddressHex and dataHex.
+     * @return  Whether the signature is valid for the supplied signerAddressHex and dataHex.
      */
     public static isValidSignature(dataHex: string, signature: ECSignature, signerAddressHex: string): boolean {
         assert.isHexString('dataHex', dataHex);
@@ -65,7 +65,7 @@ export class ZeroEx {
      * Generates a pseudo-random 256-bit salt.
      * The salt can be included in an 0x order, ensuring that the order generates a unique orderHash
      * and will not collide with other outstanding orders that are identical in all other parameters.
-     * @return A pseudo-random 256-bit number that can be used as a salt.
+     * @return  A pseudo-random 256-bit number that can be used as a salt.
      */
     public static generatePseudoRandomSalt(): BigNumber.BigNumber {
         // BigNumber.random returns a pseudo-random number between 0 & 1 with a passed in number of decimal places.
@@ -79,8 +79,8 @@ export class ZeroEx {
      * Checks if the supplied hex encoded order hash is valid.
      * Note: Valid means it has the expected format, not that an order with the orderHash exists.
      * Use this method when processing orderHashes submitted as user input.
-     * @param orderHashHex Hex encoded orderHash.
-     * @return Whether the supplied orderHashHex has the expected format.
+     * @param   orderHashHex    Hex encoded orderHash.
+     * @return  Whether the supplied orderHashHex has the expected format.
      */
     public static isValidOrderHash(orderHashHex: string): boolean {
         // Since this method can be called to check if any arbitrary string conforms to an orderHash's
@@ -93,9 +93,9 @@ export class ZeroEx {
      * A unit amount is defined as the amount of a token above the specified decimal places (integer part).
      * E.g: If a currency has 18 decimal places, 1e18 or one quintillion of the currency is equivalent
      * to 1 unit.
-     * @param amount The amount in baseUnits that you would like converted to units.
-     * @param decimals The number of decimal places the unit amount has.
-     * @return The amount in units.
+     * @param   amount      The amount in baseUnits that you would like converted to units.
+     * @param   decimals    The number of decimal places the unit amount has.
+     * @return  The amount in units.
      */
     public static toUnitAmount(amount: BigNumber.BigNumber, decimals: number): BigNumber.BigNumber {
         assert.isBigNumber('amount', amount);
@@ -109,9 +109,9 @@ export class ZeroEx {
      * A baseUnit is defined as the smallest denomination of a token. An amount expressed in baseUnits
      * is the amount expressed in the smallest denomination.
      * E.g: 1 unit of a token with 18 decimal places is expressed in baseUnits as 1000000000000000000
-     * @param amount The amount of units that you would like converted to baseUnits.
-     * @param decimals The number of decimal places the unit amount has.
-     * @return The amount in baseUnits.
+     * @param   amount      The amount of units that you would like converted to baseUnits.
+     * @param   decimals    The number of decimal places the unit amount has.
+     * @return  The amount in baseUnits.
      */
     public static toBaseUnitAmount(amount: BigNumber.BigNumber, decimals: number): BigNumber.BigNumber {
         assert.isBigNumber('amount', amount);
@@ -123,9 +123,9 @@ export class ZeroEx {
     }
     /**
      * Instantiates a new ZeroEx instance that provides the public interface to the 0x.js library.
-     * @param web3 The Web3.js instance you would like the 0x.js library to use for interacting with
-     * the Ethereum network.
-     * @return An instance of the 0x.js ZeroEx class.
+     * @param   web3    The Web3.js instance you would like the 0x.js library to use for interacting with
+     *                  the Ethereum network.
+     * @return  An instance of the 0x.js ZeroEx class.
      */
     constructor(web3: Web3) {
         this.web3Wrapper = new Web3Wrapper(web3);
@@ -136,7 +136,7 @@ export class ZeroEx {
     /**
      * Sets a new provider for the web3 instance used by 0x.js. Updating the provider will stop all
      * subscriptions so you will need to re-subscribe to all events relevant to your app after this call.
-     * @param provider The Web3.Provider you would like the 0x.js library to use from now on.
+     * @param   provider    The Web3.Provider you would like the 0x.js library to use from now on.
      */
     public async setProviderAsync(provider: Web3.Provider) {
         this.web3Wrapper.setProvider(provider);
@@ -146,7 +146,7 @@ export class ZeroEx {
     }
     /**
      * Get addresses available throught the supplied web3 instance available for sending transactions.
-     * @return An array of Ethereum addresses available.
+     * @return  An array of Ethereum addresses available.
      */
     public async getAvailableAddressesAsync(): Promise<string[]> {
         const availableAddresses = await this.web3Wrapper.getAvailableAddressesAsync();
@@ -154,8 +154,8 @@ export class ZeroEx {
     }
     /**
      * Computes the orderHash for a supplied order.
-     * @param order A JS object that conforms to the Order or SignedOrder interface definitions.
-     * @return The resulting orderHash from hashing the supplied order.
+     * @param   order   A JS object that conforms to the Order or SignedOrder interface definitions.
+     * @return  The resulting orderHash from hashing the supplied order.
      */
     public async getOrderHashHexAsync(order: Order|SignedOrder): Promise<string> {
         assert.doesConformToSchema('order', order, orderSchema);
@@ -167,10 +167,10 @@ export class ZeroEx {
     /**
      * Signs an orderHash and returns it's elliptic curve signature.
      * This method currently supports TestRPC, Geth and Parity above and below V1.6.6
-     * @param orderHashHex Hex encoded orderHash to sign.
-     * @param signerAddress The hex encoded Ethereum address you wish to sign it with. This address
-     * must be available via the Web3.Provider supplied to 0x.js.
-     * @return A JS object containing the Elliptic curve signature parameters generated by signing the orderHashHex.
+     * @param   orderHashHex    Hex encoded orderHash to sign.
+     * @param   signerAddress   The hex encoded Ethereum address you wish to sign it with. This address
+     *          must be available via the Web3.Provider supplied to 0x.js.
+     * @return  A JS object containing the Elliptic curve signature parameters generated by signing the orderHashHex.
      */
     public async signOrderHashAsync(orderHashHex: string, signerAddress: string): Promise<ECSignature> {
         assert.isHexString('orderHashHex', orderHashHex);
diff --git a/src/contract_wrappers/exchange_wrapper.ts b/src/contract_wrappers/exchange_wrapper.ts
index 48bfa9edb..76f86e464 100644
--- a/src/contract_wrappers/exchange_wrapper.ts
+++ b/src/contract_wrappers/exchange_wrapper.ts
@@ -79,8 +79,9 @@ export class ExchangeWrapper extends ContractWrapper {
      * Returns the unavailable takerAmount of an order. Unavailable amount is defined as the total
      * amount that has been filled or cancelled. The remaining takerAmount can be calculated by
      * subtracting the unavailable amount from the total order takerAmount.
-     * @param orderHashHex The hex encoded orderHash for which you would like to retrieve the unavailable takerAmount.
-     * @return The amount of the order (in taker tokens) that has either been filled or canceled.
+     * @param   orderHashHex    The hex encoded orderHash for which you would like to retrieve the
+     *                          unavailable takerAmount.
+     * @return  The amount of the order (in taker tokens) that has either been filled or canceled.
      */
     public async getUnavailableTakerAmountAsync(orderHashHex: string): Promise<BigNumber.BigNumber> {
         assert.isValidOrderHash('orderHashHex', orderHashHex);
@@ -93,8 +94,8 @@ export class ExchangeWrapper extends ContractWrapper {
     }
     /**
      * Retrieve the takerAmount of an order that has already been filled.
-     * @param orderHashHex The hex encoded orderHash for which you would like to retrieve the filled takerAmount.
-     * @return The amount of the order (in taker tokens) that has already been filled.
+     * @param   orderHashHex    The hex encoded orderHash for which you would like to retrieve the filled takerAmount.
+     * @return  The amount of the order (in taker tokens) that has already been filled.
      */
     public async getFilledTakerAmountAsync(orderHashHex: string): Promise<BigNumber.BigNumber> {
         assert.isValidOrderHash('orderHashHex', orderHashHex);
@@ -107,8 +108,9 @@ export class ExchangeWrapper extends ContractWrapper {
     }
     /**
      * Retrieve the takerAmount of an order that has been cancelled.
-     * @param orderHashHex The hex encoded orderHash for which you would like to retrieve the cancelled takerAmount.
-     * @return The amount of the order (in taker tokens) that has been cancelled.
+     * @param   orderHashHex    The hex encoded orderHash for which you would like to retrieve the
+     *                          cancelled takerAmount.
+     * @return  The amount of the order (in taker tokens) that has been cancelled.
      */
     public async getCanceledTakerAmountAsync(orderHashHex: string): Promise<BigNumber.BigNumber> {
         assert.isValidOrderHash('orderHashHex', orderHashHex);
@@ -126,12 +128,12 @@ export class ExchangeWrapper extends ContractWrapper {
      * we allow you to specify `shouldCheckTransfer`. If true, the smart contract will not throw if while
      * executing, the parties do not have sufficient balances/allowances, preserving gas costs. Setting it to
      * false forgoes this check and causes the smart contract to throw (using all the gas supplied) instead.
-     * @param signedOrder A JS object that conforms to the SignedOrder interface.
-     * @param takerTokenFillAmount The amount of the order (in taker tokens baseUnits) that you wish to fill.
-     * @param shouldCheckTransfer Whether or not you wish for the contract call to throw if upon
-     * execution the tokens cannot be transferred.
-     * @param takerAddress The user Ethereum address who would like to fill this order. Must be available via the
-     * supplied Web3.Provider passed to 0x.js.
+     * @param   signedOrder             A JS object that conforms to the SignedOrder interface.
+     * @param   takerTokenFillAmount    The amount of the order (in taker tokens baseUnits) that you wish to fill.
+     * @param   shouldCheckTransfer     Whether or not you wish for the contract call to throw if upon
+     *                                  execution the tokens cannot be transferred.
+     * @param   takerAddress            The user Ethereum address who would like to fill this order.
+     *                                  Must be available via the supplied Web3.Provider passed to 0x.js.
      */
     public async fillOrderAsync(signedOrder: SignedOrder, takerTokenFillAmount: BigNumber.BigNumber,
                                 shouldCheckTransfer: boolean, takerAddress: string): Promise<void> {
@@ -176,13 +178,15 @@ export class ExchangeWrapper extends ContractWrapper {
      * Sequentially and atomically fills signedOrders up to the specified takerTokenFillAmount.
      * If the fill amount is reached - it succeeds and does not fill the rest of the orders.
      * If fill amount is not reached - it fills as much of the fill amount as possible and succeeds.
-     * @param signedOrders The array of signedOrders that you would like to fill until takerTokenFillAmount is reached.
-     * @param takerTokenFillAmount The total amount of the takerTokens you would like to fill.
-     * @param shouldCheckTransfer Whether or not you wish for the contract call to throw if upon
-     * execution any of the tokens cannot be transferred. If set to false, the call will continue to fill subsequent
-     * signedOrders even when some cannot be filled.
-     * @param takerAddress The user Ethereum address who would like to fill these orders. Must be available via the
-     * supplied Web3.Provider passed to 0x.js.
+     * @param   signedOrders            The array of signedOrders that you would like to fill until
+     *                                  takerTokenFillAmount is reached.
+     * @param   takerTokenFillAmount    The total amount of the takerTokens you would like to fill.
+     * @param   shouldCheckTransfer     Whether or not you wish for the contract call to throw if upon
+     *                                  execution any of the tokens cannot be transferred. If set to false,
+     *                                  the call will continue to fill subsequent signedOrders even when
+     *                                  some cannot be filled.
+     * @param   takerAddress            The user Ethereum address who would like to fill these orders.
+     *                                  Must be available via the supplied Web3.Provider passed to 0x.js.
      */
     public async fillOrdersUpToAsync(signedOrders: SignedOrder[], takerTokenFillAmount: BigNumber.BigNumber,
                                      shouldCheckTransfer: boolean, takerAddress: string): Promise<void> {
@@ -247,12 +251,13 @@ export class ExchangeWrapper extends ContractWrapper {
      * Executes multiple fills atomically in a single transaction.
      * If shouldCheckTransfer is set to true, it will continue filling subsequent orders even when earlier ones fail.
      * When shouldCheckTransfer is set to false, if any fill fails, the entire batch fails.
-     * @param orderFillRequests An array of JS objects that conform to the OrderFillRequest interface.
-     * @param shouldCheckTransfer Whether or not you wish for the contract call to throw if upon
-     * execution any of the tokens cannot be transferred. If set to false, the call will continue to fill subsequent
-     * signedOrders even when some cannot be filled.
-     * @param takerAddress The user Ethereum address who would like to fill these orders. Must be available via the
-     * supplied Web3.Provider passed to 0x.js.
+     * @param   orderFillRequests       An array of JS objects that conform to the OrderFillRequest interface.
+     * @param   shouldCheckTransfer     Whether or not you wish for the contract call to throw if upon
+     *                                  execution any of the tokens cannot be transferred. If set to false,
+     *                                  the call will continue to fill subsequent signedOrders even when some
+     *                                  cannot be filled.
+     * @param   takerAddress            The user Ethereum address who would like to fill these orders.
+     *                                  Must be available via the supplied Web3.Provider passed to 0x.js.
      */
     public async batchFillOrderAsync(orderFillRequests: OrderFillRequest[],
                                      shouldCheckTransfer: boolean, takerAddress: string): Promise<void> {
@@ -312,10 +317,11 @@ export class ExchangeWrapper extends ContractWrapper {
     /**
      * Attempts to fill a specific amount of an order. If the entire amount specified cannot be filled,
      * the fill order is abandoned.
-     * @param signedOrder A JS object that conforms to the SignedOrder interface. The signedOrder you wish to fill.
-     * @param takerTokenFillAmount The total amount of the takerTokens you would like to fill.
-     * @param takerAddress The user Ethereum address who would like to fill this order. Must be available via the
-     * supplied Web3.Provider passed to 0x.js.
+     * @param   signedOrder             A JS object that conforms to the SignedOrder interface. The
+     *                                  signedOrder you wish to fill.
+     * @param   takerTokenFillAmount    The total amount of the takerTokens you would like to fill.
+     * @param   takerAddress            The user Ethereum address who would like to fill this order.
+     *                                  Must be available via the supplied Web3.Provider passed to 0x.js.
      */
     public async fillOrKillOrderAsync(signedOrder: SignedOrder, takerTokenFillAmount: BigNumber.BigNumber,
                                       takerAddress: string): Promise<void> {
@@ -359,9 +365,9 @@ export class ExchangeWrapper extends ContractWrapper {
     /**
      * Batch version of fillOrKill. Allows a taker to specify a batch of orders that will either be atomically
      * filled (each to the specified fillAmount) or aborted.
-     * @param orderFillOrKillRequests An array of JS objects that conform to the OrderFillOrKillRequest interface.
-     * @param takerAddress The user Ethereum address who would like to fill there orders. Must be available via the
-     * supplied Web3.Provider passed to 0x.js.
+     * @param   orderFillOrKillRequests     An array of JS objects that conform to the OrderFillOrKillRequest interface.
+     * @param   takerAddress                The user Ethereum address who would like to fill there orders.
+     *                                      Must be available via the supplied Web3.Provider passed to 0x.js.
      */
     public async batchFillOrKillAsync(orderFillOrKillRequests: OrderFillOrKillRequest[],
                                       takerAddress: string): Promise<void> {
@@ -414,6 +420,9 @@ export class ExchangeWrapper extends ContractWrapper {
     }
     /**
      * Cancel a given fill amount of an order. Cancellations are cumulative.
+     * @param   order                   A JS object that conforms to the Order or SignedOrder interface.
+     *                                  The order you would like to cancel.
+     * @param   takerTokenCancelAmount  The amount (specified in taker tokens) that you would like to cancel.
      */
     public async cancelOrderAsync(
         order: Order|SignedOrder, takerTokenCancelAmount: BigNumber.BigNumber): Promise<void> {
@@ -447,7 +456,8 @@ export class ExchangeWrapper extends ContractWrapper {
     /**
      * Batch version of cancelOrderAsync. Atomically cancels multiple orders in a single transaction.
      * All orders must be from the same maker.
-     * @param orderCancellationRequests An array of JS objects that conform to the OrderCancellationRequest interface.
+     * @param   orderCancellationRequests   An array of JS objects that conform to the OrderCancellationRequest
+     *                                      interface.
      */
     public async batchCancelOrderAsync(orderCancellationRequests: OrderCancellationRequest[]): Promise<void> {
         const makers = _.map(orderCancellationRequests, cancellationRequest => cancellationRequest.order.maker);
@@ -495,11 +505,11 @@ export class ExchangeWrapper extends ContractWrapper {
     }
     /**
      * Subscribe to an event type emitted by the Exchange smart contract
-     * @param eventName The exchange contract event you would like to subscribe to.
-     * @param subscriptionOpts Subscriptions options that let you configure the subscription.
-     * @param indexFilterValues A JS object where the keys are indexed args returned by the event and
-     * the value is the value you are interested in. E.g `{maker: aUserAddressHex}`
-     * @param callback The callback that will be called everytime a matching event is found.
+     * @param   eventName           The exchange contract event you would like to subscribe to.
+     * @param   subscriptionOpts    Subscriptions options that let you configure the subscription.
+     * @param   indexFilterValues   A JS object where the keys are indexed args returned by the event and
+     *                              the value is the value you are interested in. E.g `{maker: aUserAddressHex}`
+     * @param   callback            The callback that will be called everytime a matching event is found.
      */
     public async subscribeAsync(eventName: ExchangeEvents, subscriptionOpts: SubscriptionOpts,
                                 indexFilterValues: IndexFilterValues, callback: EventCallback):
diff --git a/src/contract_wrappers/token_registry_wrapper.ts b/src/contract_wrappers/token_registry_wrapper.ts
index 5987dfca6..96346a7a4 100644
--- a/src/contract_wrappers/token_registry_wrapper.ts
+++ b/src/contract_wrappers/token_registry_wrapper.ts
@@ -15,7 +15,7 @@ export class TokenRegistryWrapper extends ContractWrapper {
     }
     /**
      * Retrieves all the tokens currently listed in the Token Registry smart contract
-     * @return An array of JS objects that conform to the Token interface.
+     * @return  An array of JS objects that conform to the Token interface.
      */
     public async getTokensAsync(): Promise<Token[]> {
         const tokenRegistryContract = await this.getTokenRegistryContractAsync();
diff --git a/src/contract_wrappers/token_wrapper.ts b/src/contract_wrappers/token_wrapper.ts
index e6ef64c55..bb79cac47 100644
--- a/src/contract_wrappers/token_wrapper.ts
+++ b/src/contract_wrappers/token_wrapper.ts
@@ -21,8 +21,8 @@ export class TokenWrapper extends ContractWrapper {
     }
     /**
      * Retrieves an owner's ERC20 token balance.
-     * @param tokenAddress The hex encoded contract Ethereum address where the ERC20 token is deployed.
-     * @param ownerAddress The hex encoded user Ethereum address whose balance you would like to check.
+     * @param   tokenAddress    The hex encoded contract Ethereum address where the ERC20 token is deployed.
+     * @param   ownerAddress    The hex encoded user Ethereum address whose balance you would like to check.
      */
     public async getBalanceAsync(tokenAddress: string, ownerAddress: string): Promise<BigNumber.BigNumber> {
         assert.isETHAddressHex('ownerAddress', ownerAddress);
@@ -38,10 +38,11 @@ export class TokenWrapper extends ContractWrapper {
     /**
      * Sets the spender's allowance to a specified number of baseUnits on behalf of the owner address.
      * Equivalent to the ERC20 spec method `approve`.
-     * @param tokenAddress The hex encoded contract Ethereum address where the ERC20 token is deployed.
-     * @param ownerAddress The hex encoded user Ethereum address who would like to set an allowance for spenderAddress
-     * @param spenderAddress The hex encoded user Ethereum address who will be able to spend the set allowance.
-     * @param amountInBaseUnits The allowance amount you would like to set.
+     * @param   tokenAddress        The hex encoded contract Ethereum address where the ERC20 token is deployed.
+     * @param   ownerAddress        The hex encoded user Ethereum address who would like to set an allowance
+     *                              for spenderAddress.
+     * @param   spenderAddress      The hex encoded user Ethereum address who will be able to spend the set allowance.
+     * @param   amountInBaseUnits   The allowance amount you would like to set.
      */
     public async setAllowanceAsync(tokenAddress: string, ownerAddress: string, spenderAddress: string,
                                    amountInBaseUnits: BigNumber.BigNumber): Promise<void> {
@@ -63,10 +64,10 @@ export class TokenWrapper extends ContractWrapper {
     }
     /**
      * Retrieves the owners allowance in baseUnits set to the spender's address.
-     * @param tokenAddress The hex encoded contract Ethereum address where the ERC20 token is deployed.
-     * @param ownerAddress The hex encoded user Ethereum address whose allowance to spenderAddress
-     * you would like to retrieve.
-     * @param spenderAddress The hex encoded user Ethereum address who can spend the allowance you are fetching.
+     * @param   tokenAddress    The hex encoded contract Ethereum address where the ERC20 token is deployed.
+     * @param   ownerAddress    The hex encoded user Ethereum address whose allowance to spenderAddress
+     *                          you would like to retrieve.
+     * @param   spenderAddress  The hex encoded user Ethereum address who can spend the allowance you are fetching.
      */
     public async getAllowanceAsync(tokenAddress: string, ownerAddress: string, spenderAddress: string) {
         assert.isETHAddressHex('ownerAddress', ownerAddress);
@@ -81,8 +82,8 @@ export class TokenWrapper extends ContractWrapper {
     }
     /**
      * Retrieves the owner's allowance in baseUnits set to the 0x proxy contract.
-     * @param tokenAddress The hex encoded contract Ethereum address where the ERC20 token is deployed.
-     * @param ownerAddress The hex encoded user Ethereum address whose proxy contract allowance we are retrieving.
+     * @param   tokenAddress    The hex encoded contract Ethereum address where the ERC20 token is deployed.
+     * @param   ownerAddress    The hex encoded user Ethereum address whose proxy contract allowance we are retrieving.
      */
     public async getProxyAllowanceAsync(tokenAddress: string, ownerAddress: string) {
         assert.isETHAddressHex('ownerAddress', ownerAddress);
@@ -95,9 +96,10 @@ export class TokenWrapper extends ContractWrapper {
     /**
      * Sets the 0x proxy contract's allowance to a specified number of a tokens' baseUnits on behalf
      * of an owner address.
-     * @param tokenAddress The hex encoded contract Ethereum address where the ERC20 token is deployed.
-     * @param ownerAddress The hex encoded user Ethereum address who is setting an allowance for the Proxy contract.
-     * @param amountInBaseUnits The allowance amount specified in baseUnits.
+     * @param   tokenAddress        The hex encoded contract Ethereum address where the ERC20 token is deployed.
+     * @param   ownerAddress        The hex encoded user Ethereum address who is setting an allowance
+     *                              for the Proxy contract.
+     * @param   amountInBaseUnits   The allowance amount specified in baseUnits.
      */
     public async setProxyAllowanceAsync(tokenAddress: string, ownerAddress: string,
                                         amountInBaseUnits: BigNumber.BigNumber): Promise<void> {
@@ -110,10 +112,10 @@ export class TokenWrapper extends ContractWrapper {
     }
     /**
      * Transfers `amountInBaseUnits` ERC20 tokens from `fromAddress` to `toAddress`.
-     * @param tokenAddress The hex encoded contract Ethereum address where the ERC20 token is deployed.
-     * @param fromAddress The hex encoded user Ethereum address that will send the funds.
-     * @param toAddress The hex encoded user Ethereum address that will receive the funds.
-     * @param amountInBaseUnits The amount (specified in baseUnits) of the token to transfer.
+     * @param   tokenAddress        The hex encoded contract Ethereum address where the ERC20 token is deployed.
+     * @param   fromAddress         The hex encoded user Ethereum address that will send the funds.
+     * @param   toAddress           The hex encoded user Ethereum address that will receive the funds.
+     * @param   amountInBaseUnits   The amount (specified in baseUnits) of the token to transfer.
      */
     public async transferAsync(tokenAddress: string, fromAddress: string, toAddress: string,
                                amountInBaseUnits: BigNumber.BigNumber): Promise<void> {
@@ -137,12 +139,12 @@ export class TokenWrapper extends ContractWrapper {
      * Transfers `amountInBaseUnits` ERC20 tokens from `fromAddress` to `toAddress`.
      * Requires the fromAddress to have sufficient funds and to have approved an allowance of
      * `amountInBaseUnits` for senderAddress.
-     * @param tokenAddress The hex encoded contract Ethereum address where the ERC20 token is deployed.
-     * @param fromAddress The hex encoded user Ethereum address that will send the funds.
-     * @param toAddress The hex encoded user Ethereum address that will receive the funds.
-     * @param senderAddress The hex encoded user Ethereum address whose funds are being sent. The senderAddress
-     * must have set an allowance to the fromAddress before this call.
-     * @param amountInBaseUnits The amount (specified in baseUnits) of the token to transfer.
+     * @param   tokenAddress        The hex encoded contract Ethereum address where the ERC20 token is deployed.
+     * @param   fromAddress         The hex encoded user Ethereum address that will send the funds.
+     * @param   toAddress           The hex encoded user Ethereum address that will receive the funds.
+     * @param   senderAddress       The hex encoded user Ethereum address whose funds are being sent. The senderAddress
+     *                              must have set an allowance to the fromAddress before this call.
+     * @param   amountInBaseUnits   The amount (specified in baseUnits) of the token to transfer.
      */
     public async transferFromAsync(tokenAddress: string, fromAddress: string, toAddress: string,
                                    senderAddress: string, amountInBaseUnits: BigNumber.BigNumber):