path: root/packages/contracts/util/exchange_wrapper.ts

import {BigNumber} from 'bignumber.js';
import * as _ from 'lodash';

import {formatters} from './formatters';
import {Order} from './order';
import {ContractInstance} from './types';

export class ExchangeWrapper {
  private exchange: ContractInstance;
  constructor(exchangeContractInstance: ContractInstance) {
    this.exchange = exchangeContractInstance;
  }
  public async fillOrderAsync(order: Order, from: string,
                              opts: {
                                  fillTakerTokenAmount?: BigNumber;
                                  shouldThrowOnInsufficientBalanceOrAllowance?: boolean;
                              } = {}) {
    const shouldThrowOnInsufficientBalanceOrAllowance = !!opts.shouldThrowOnInsufficientBalanceOrAllowance;
    const params = order.createFill(shouldThrowOnInsufficientBalanceOrAllowance, opts.fillTakerTokenAmount);
    const tx = await this.exchange.fillOrder(
      params.orderAddresses,
      params.orderValues,
      params.fillTakerTokenAmount,
      params.shouldThrowOnInsufficientBalanceOrAllowance,
      params.v,
      params.r,
      params.s,
      {from},
    );
    _.each(tx.logs, log => wrapLogBigNumbers(log));
    return tx;
  }
  public async cancelOrderAsync(order: Order, from: string,
                                opts: {cancelTakerTokenAmount?: BigNumber} = {}) {
    const params = order.createCancel(opts.cancelTakerTokenAmount);
    const tx = await this.exchange.cancelOrder(
      params.orderAddresses,
      params.orderValues,
      params.cancelTakerTokenAmount,
      {from},
    );
    _.each(tx.logs, log => wrapLogBigNumbers(log));
    return tx;
  }
  public async fillOrKillOrderAsync(order: Order, from: string,
                                    opts: {fillTakerTokenAmount?: BigNumber} = {}) {
    const shouldThrowOnInsufficientBalanceOrAllowance = true;
    const params = order.createFill(shouldThrowOnInsufficientBalanceOrAllowance, opts.fillTakerTokenAmount);
    const tx = await this.exchange.fillOrKillOrder(
      params.orderAddresses,
      params.orderValues,
      params.fillTakerTokenAmount,
      params.v,
      params.r,
      params.s,
      {from},
    );
    _.each(tx.logs, log => wrapLogBigNumbers(log));
    return tx;
  }
  public async batchFillOrdersAsync(orders: Order[], from: string,
                                    opts: {
                                        fillTakerTokenAmounts?: BigNumber[];
                                        shouldThrowOnInsufficientBalanceOrAllowance?: boolean;
                                    } = {}) {
    const shouldThrowOnInsufficientBalanceOrAllowance = !!opts.shouldThrowOnInsufficientBalanceOrAllowance;
    const params = formatters.createBatchFill(
        orders, shouldThrowOnInsufficientBalanceOrAllowance, opts.fillTakerTokenAmounts);
    const tx = await this.exchange.batchFillOrders(
      params.orderAddresses,
      params.orderValues,
      params.fillTakerTokenAmounts,
      params.shouldThrowOnInsufficientBalanceOrAllowance,
      params.v,
      params.r,
      params.s,
      {from},
    );
    _.each(tx.logs, log => wrapLogBigNumbers(log));
    return tx;
  }
  public async batchFillOrKillOrdersAsync(orders: Order[], from: string,
                                          opts: {
                                              fillTakerTokenAmounts?: BigNumber[];
                                          } = {}) {
    const params = formatters.createBatchFill(orders, undefined, opts.fillTakerTokenAmounts);
    const tx = await this.exchange.batchFillOrKillOrders(
      params.orderAddresses,
      params.orderValues,
      params.fillTakerTokenAmounts,
      params.v,
      params.r,
      params.s,
      {from},
    );
    _.each(tx.logs, log => wrapLogBigNumbers(log));
    return tx;
  }
  public async fillOrdersUpToAsync(orders: Order[], from: string,
                                   opts: {fillTakerTokenAmount?: BigNumber;
                                          shouldThrowOnInsufficientBalanceOrAllowance?: boolean;
                                   } = {}) {
    const shouldThrowOnInsufficientBalanceOrAllowance = !!opts.shouldThrowOnInsufficientBalanceOrAllowance;
    const params = formatters.createFillUpTo(orders,
                                             shouldThrowOnInsufficientBalanceOrAllowance,
                                             opts.fillTakerTokenAmount);
    const tx = await this.exchange.fillOrdersUpTo(
      params.orderAddresses,
      params.orderValues,
      params.fillTakerTokenAmount,
      params.shouldThrowOnInsufficientBalanceOrAllowance,
      params.v,
      params.r,
      params.s,
      {from},
    );
    _.each(tx.logs, log => wrapLogBigNumbers(log));
    return tx;
  }
  public async batchCancelOrdersAsync(orders: Order[], from: string,
                                      opts: {cancelTakerTokenAmounts?: BigNumber[]} = {}) {
    const params = formatters.createBatchCancel(orders, opts.cancelTakerTokenAmounts);
    const tx = await this.exchange.batchCancelOrders(
      params.orderAddresses,
      params.orderValues,
      params.cancelTakerTokenAmounts,
      {from},
    );
    _.each(tx.logs, log => wrapLogBigNumbers(log));
    return tx;
  }
  public async getOrderHashAsync(order: Order): Promise<string> {
    const shouldThrowOnInsufficientBalanceOrAllowance = false;
    const params = order.createFill(shouldThrowOnInsufficientBalanceOrAllowance);
    const orderHash = await this.exchange.getOrderHash(params.orderAddresses, params.orderValues);
    return orderHash;
  }
  public async isValidSignatureAsync(order: Order): Promise<boolean> {
    const isValidSignature = await this.exchange.isValidSignature(
      order.params.maker,
      order.params.orderHashHex,
      order.params.v,
      order.params.r,
      order.params.s,
    );
    return isValidSignature;
  }
  public async isRoundingErrorAsync(numerator: BigNumber, denominator: BigNumber,
                                    target: BigNumber): Promise<boolean> {
    const isRoundingError = await this.exchange.isRoundingError(numerator, denominator, target);
    return isRoundingError;
  }
  public async getPartialAmountAsync(numerator: BigNumber, denominator: BigNumber,
                                     target: BigNumber): Promise<BigNumber> {
    const partialAmount = new BigNumber(await this.exchange.getPartialAmount(numerator, denominator, target));
    return partialAmount;
  }
}

function wrapLogBigNumbers(log: any): any {
  const argNames = _.keys(log.args);
  for (const argName of argNames) {
    const isWeb3BigNumber = _.startsWith(log.args[argName].constructor.toString(), 'function BigNumber(');
    if (isWeb3BigNumber) {
      log.args[argName] = new BigNumber(log.args[argName]);
    }
  }
}