feat: dding the alternative ERC20 wrapper back in

Author: Victor Wiebe

src/contract_wrappers/tokens/__tests__/alternative_erc20_wrapper.test.ts

@@ -0,0 +1,119 @@
+// PolymathRegistryWrapper test
+import { mock, instance, reset, when, verify } from 'ts-mockito';
+import { Web3Wrapper } from '@0x/web3-wrapper';
+import { ERC20DetailedContract, SecurityTokenRegistryEvents } from '@polymathnetwork/abi-wrappers';
+import { BigNumber } from '@0x/utils';
+import ERC20TokenWrapper from '../erc20_wrapper';
+import AlternativeERC20TokenWrapper from '../alternative_erc20_wrapper';
+import { MockedCallMethod } from '../../../test_utils/mocked_methods';
+import { bytes32ToString, stringToBytes32 } from '../../../utils/convert';
+
+describe('AlternativeERC20TokenWrapper', () => {
+  // Declare ERC20DetailedTokenWrapper object
+  let target: AlternativeERC20TokenWrapper;
+  let mockedWrapper: Web3Wrapper;
+  let mockedContract: ERC20DetailedContract;
+
+  beforeAll(() => {
+    mockedWrapper = mock(Web3Wrapper);
+    mockedContract = mock(ERC20DetailedContract);
+
+    const myContractPromise = Promise.resolve(instance(mockedContract));
+    target = new AlternativeERC20TokenWrapper(instance(mockedWrapper), myContractPromise);
+  });
+
+  afterEach(() => {
+    reset(mockedWrapper);
+    reset(mockedContract);
+  });
+
+  describe('Types', () => {
+    test('should extend ERC20TokenWrapper', async () => {
+      expect(target instanceof ERC20TokenWrapper).toBe(true);
+    });
+  });
+
+  describe('name', () => {
+    test('should call to name', async () => {
+      const expectedResult = stringToBytes32('string');
+      // Mocked method
+      const mockedMethod = mock(MockedCallMethod);
+      // Stub the method
+      when(mockedContract.name).thenReturn(instance(mockedMethod));
+      // Stub the request
+      when(mockedMethod.callAsync()).thenResolve(expectedResult);
+
+      // Real call
+      const result = await target.name();
+      // Result expectation
+      expect(result).toBe(bytes32ToString(expectedResult));
+      // Verifications
+      verify(mockedContract.name).once();
+      verify(mockedMethod.callAsync()).once();
+    });
+  });
+
+  describe('symbol', () => {
+    test('should call to symbol', async () => {
+      const expectedResult = stringToBytes32('string');
+      // Mocked method
+      const mockedMethod = mock(MockedCallMethod);
+      // Stub the method
+      when(mockedContract.symbol).thenReturn(instance(mockedMethod));
+      // Stub the request
+      when(mockedMethod.callAsync()).thenResolve(expectedResult);
+
+      // Real call
+      const result = await target.symbol();
+      // Result expectation
+      expect(result).toBe(bytes32ToString(expectedResult));
+      // Verifications
+      verify(mockedContract.symbol).once();
+      verify(mockedMethod.callAsync()).once();
+    });
+  });
+
+  describe('isValidContract', () => {
+    test('should call to isValidContract', async () => {
+      const expectedBNResult = new BigNumber(1);
+      const expectedStringResult = stringToBytes32('string');
+
+      const mockedTotalSupplyMethod = mock(MockedCallMethod);
+      when(mockedContract.totalSupply).thenReturn(instance(mockedTotalSupplyMethod));
+      when(mockedTotalSupplyMethod.callAsync()).thenResolve(expectedBNResult);
+
+      const mockedSymbolMethod = mock(MockedCallMethod);
+      when(mockedContract.symbol).thenReturn(instance(mockedSymbolMethod));
+      when(mockedSymbolMethod.callAsync()).thenResolve(expectedStringResult);
+
+      const mockedNameMethod = mock(MockedCallMethod);
+      when(mockedContract.name).thenReturn(instance(mockedNameMethod));
+      when(mockedSymbolMethod.callAsync()).thenResolve(expectedStringResult);
+
+      const expectedIsValidResult = false;
+      const result = await target.isValidContract();
+      expect(result).toBe(expectedIsValidResult);
+
+      verify(mockedContract.totalSupply).once();
+      verify(mockedContract.symbol).once();
+      verify(mockedContract.name).once();
+    });
+  });
+
+  describe('SubscribeAsync', () => {
+    test('should throw as eventName does not belong to SecurityTokenRegistryEvents', async () => {
+      // Mocked parameters
+      const mockedParams = {
+        eventName: SecurityTokenRegistryEvents.ChangeExpiryLimit,
+        indexFilterValues: {},
+        callback: () => {},
+        isVerbose: false,
+      };
+
+      // Real call
+      await expect(target.subscribeAsync(mockedParams)).rejects.toEqual(
+        new Error(`Expected eventName to be one of: 'Transfer', 'Approval', encountered: ChangeExpiryLimit`),
+      );
+    });
+  });
+});

src/contract_wrappers/tokens/alternative_erc20_wrapper.ts

@@ -0,0 +1,97 @@
+import { ERC20DetailedContract, ERC20DetailedEventArgs, ERC20DetailedEvents } from '@polymathnetwork/abi-wrappers';
+import { ERC20Detailed } from '@polymathnetwork/contract-artifacts';
+import { LogWithDecodedArgs, Web3Wrapper } from '@0x/web3-wrapper';
+import { ContractAbi } from 'ethereum-types';
+import { schemas } from '@0x/json-schemas';
+import { bytes32ToString } from '../../utils/convert';
+import ERC20TokenWrapper from './erc20_wrapper';
+import { GetLogs, GetLogsAsyncParams, Subscribe, SubscribeAsyncParams } from '../../types';
+
+import assert from '../../utils/assert';
+
+import _ = require('lodash');
+
+/**
+ * This class includes the functionality related to interacting with the AlternativeERC20 contract.
+ */
+export default class AlternativeERC20Wrapper extends ERC20TokenWrapper {
+  public abi: ContractAbi = ERC20Detailed.abi;
+
+  protected contract: Promise<ERC20DetailedContract>;
+
+  /**
+   * Instantiate AlternativeERC20Wrapper
+   * @param web3Wrapper Web3Wrapper instance to use
+   * @param contract
+   */
+  public constructor(web3Wrapper: Web3Wrapper, contract: Promise<ERC20DetailedContract>) {
+    super(web3Wrapper, contract);
+    this.contract = contract;
+  }
+
+  /**
+   * Returns the token name
+   */
+  public name = async () => {
+    const name = (await this.contract).name.callAsync();
+    return bytes32ToString(await name);
+  };
+
+  /**
+   * Returns the token symbol
+   */
+  public symbol = async () => {
+    const symbol = (await this.contract).symbol.callAsync();
+    return bytes32ToString(await symbol);
+  };
+
+  public async isValidContract() {
+    try {
+      const contract = await this.contract;
+      const totalSupply = await contract.totalSupply.callAsync();
+      const symbol = await contract.symbol.callAsync();
+      const name = await contract.name.callAsync();
+      if (bytes32ToString(symbol) === '' || bytes32ToString(name) === '' || totalSupply.isZero()) {
+        return false;
+      }
+      return true;
+    } catch (error) {
+      return false;
+    }
+  }
+
+  public subscribeAsync: Subscribe = async <ArgsType extends ERC20DetailedEventArgs>(
+    params: SubscribeAsyncParams,
+  ): Promise<string> => {
+    assert.doesBelongToStringEnum('eventName', params.eventName, ERC20DetailedEvents);
+    assert.doesConformToSchema('indexFilterValues', params.indexFilterValues, schemas.indexFilterValuesSchema);
+    assert.isFunction('callback', params.callback);
+    const normalizedContractAddress = (await this.contract).address.toLowerCase();
+    const subscriptionToken = this.subscribeInternal<ArgsType>(
+      normalizedContractAddress,
+      params.eventName,
+      params.indexFilterValues,
+      ERC20Detailed.abi,
+      params.callback,
+      !_.isUndefined(params.isVerbose),
+    );
+    return subscriptionToken;
+  };
+
+  public getLogsAsync: GetLogs = async <ArgsType extends ERC20DetailedEventArgs>(
+    params: GetLogsAsyncParams,
+  ): Promise<LogWithDecodedArgs<ArgsType>[]> => {
+    assert.doesBelongToStringEnum('eventName', params.eventName, ERC20DetailedEvents);
+    assert.doesConformToSchema('blockRange', params.blockRange, schemas.blockRangeSchema);
+    assert.doesConformToSchema('indexFilterValues', params.indexFilterValues, schemas.indexFilterValuesSchema);
+    const normalizedContractAddress = (await this.contract).address.toLowerCase();
+    const logs = await this.getLogsAsyncInternal<ArgsType>(
+      normalizedContractAddress,
+      params.eventName,
+      params.blockRange,
+      params.indexFilterValues,
+      ERC20Detailed.abi,
+    );
+    return logs;
+  };
+}