Updated the erc1155 tests to expect RichErrors

contracts/erc1155/test/erc1155_token.ts

@@ -8,7 +8,7 @@ import {
 } from '@0x/contracts-test-utils';
 import { BlockchainLifecycle } from '@0x/dev-utils';
 import { RevertReason } from '@0x/types';
-import { BigNumber } from '@0x/utils';
+import { BigNumber, SafeMathRevertErrors } from '@0x/utils';
 import * as chai from 'chai';
 import { LogWithDecodedArgs } from 'ethereum-types';
 import * as _ from 'lodash';
@@ -171,18 +171,21 @@ describe('ERC1155Token', () => {
             // setup test parameters
             const tokenToTransfer = fungibleToken;
             const valueToTransfer = spenderInitialFungibleBalance.plus(1);
-            // execute transfer
-            await expectTransactionFailedAsync(
-                erc1155Contract.safeTransferFrom.sendTransactionAsync(
-                    spender,
-                    receiver,
-                    tokenToTransfer,
-                    valueToTransfer,
-                    receiverCallbackData,
-                    { from: spender },
-                ),
-                RevertReason.Uint256Underflow,
+            // create the expected error (a uint256 underflow)
+            let expectedError = new SafeMathRevertErrors.Uint256UnderflowError(
+                spenderInitialFungibleBalance, 
+                valueToTransfer
             );
+            // execute transfer
+            let tx = erc1155Contract.safeTransferFrom.sendTransactionAsync(
+                spender,
+                receiver,
+                tokenToTransfer,
+                valueToTransfer,
+                receiverCallbackData,
+                { from: spender },
+            );
+            expect(tx).to.revertWith(expectedError);
         });
         it('should throw if callback reverts', async () => {
             // setup test parameters
@@ -343,18 +346,21 @@ describe('ERC1155Token', () => {
             // setup test parameters
             const tokensToTransfer = [fungibleToken];
             const valuesToTransfer = [spenderInitialFungibleBalance.plus(1)];
-            // execute transfer
-            await expectTransactionFailedAsync(
-                erc1155Contract.safeBatchTransferFrom.sendTransactionAsync(
-                    spender,
-                    receiver,
-                    tokensToTransfer,
-                    valuesToTransfer,
-                    receiverCallbackData,
-                    { from: spender },
-                ),
-                RevertReason.Uint256Underflow,
+            // create the expected error (a uint256 underflow)
+            let expectedError = new SafeMathRevertErrors.Uint256UnderflowError(
+                spenderInitialFungibleBalance, 
+                valuesToTransfer
             );
+            // execute transfer
+            let tx = erc1155Contract.safeBatchTransferFrom.sendTransactionAsync(
+                spender,
+                receiver,
+                tokensToTransfer,
+                valuesToTransfer,
+                receiverCallbackData,
+                { from: spender },
+            );
+            expect(tx).to.revertWith(expectedError);
         });
         it('should throw if callback reverts', async () => {
             // setup test parameters

packages/utils/src/index.ts

@@ -1,3 +1,6 @@
+import * as OwnableRevertErrors from './ownable_revert_errors';
+import * as SafeMathRevertErrors from './safe_math_revert_errors';
+
 export { promisify } from './promisify';
 export { addressUtils } from './address_utils';
 export { classUtils } from './class_utils';
@@ -24,3 +27,5 @@ export {
     StringRevertError,
     AnyRevertError,
 } from './revert_error';
+
+export { OwnableRevertErrors, SafeMathRevertErrors };

packages/utils/src/ownable_revert_errors.ts

@@ -0,0 +1,14 @@
+import { BigNumber } from './configured_bignumber';
+import { RevertError } from './revert_error';
+
+export class OnlyOwnerError extends RevertError {
+    constructor(sender?: string, owner?: string) {
+        super('OnlyOwnerError', 'OnlyOwnerError(address sender, address owner)', {
+            sender,
+            owner,
+        });
+    }
+}
+
+// Register the OnlyOwnerError type
+RevertError.registerType(OnlyOwnerError);

packages/utils/src/safe_math_revert_errors.ts

@@ -0,0 +1,32 @@
+import { BigNumber } from './configured_bignumber';
+import { RevertError } from './revert_error';
+
+// tslint:disable:max-classes-per-file
+
+export class Uint256OverflowError extends RevertError {
+    constructor(a?: BigNumber | number | string, b?: BigNumber | number | string) {
+        super('Uint256OverflowError', 'Uint256OverflowError(uint256 a, uint256 b)', {
+            a,
+            b,
+        });
+    }
+}
+
+export class Uint256UnderflowError extends RevertError {
+    constructor(a?: BigNumber | number | string, b?: BigNumber | number | string) {
+        super('Uint256UnderflowError', 'Uint256UnderflowError(uint256 a, uint256 b)', {
+            a,
+            b,
+        });
+    }
+}
+
+const types = [
+    Uint256OverflowError,
+    Uint256UnderflowError,
+]
+
+// Register the types we've defined.
+for (const type of types) {
+    RevertError.registerType(type);
+}