crowetic/protocol
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Remove ContractNotFound errors in contract-wrappers

Browse Source
This commit is contained in:
Alex Browne
2018-10-16 00:11:58 -07:00
parent 3c5812c5d2
commit 5bdfad9b41
8 changed files with 5 additions and 79 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
packages/contract-wrappers/CHANGELOG.json
View File

@@ -32,6 +32,11 @@
"note":
"Some properties and methods have been renamed. For example, some methods that previously could throw no longer can, and so their names have been updated accordingly.",
"pr": 1105
},
{
"note":
"Removed ContractNotFound errors. Checking for this error was somewhat ineffecient. Relevant methods/functions now return the default error from web3-wrapper, which we feel provides enough information.",
"pr": 1105
}
]
},

6
packages/contract-wrappers/src/contract_wrappers/erc20_token_wrapper.ts
View File

@@ -428,12 +428,6 @@ export class ERC20TokenWrapper extends ContractWrapper {
if (!_.isUndefined(tokenContract)) {
return tokenContract;
}
// TODO(albrow): Do we really still need this check? The default error
// looks okay to me.
const doesContractExist = await this._web3Wrapper.doesContractExistAtAddressAsync(tokenAddress);
if (!doesContractExist) {
throw new Error(ContractWrappersError.ERC20TokenContractDoesNotExist);
}
const contractInstance = new ERC20TokenContract(
this.abi,
normalizedTokenAddress,

6
packages/contract-wrappers/src/contract_wrappers/erc721_token_wrapper.ts
View File

@@ -455,12 +455,6 @@ export class ERC721TokenWrapper extends ContractWrapper {
if (!_.isUndefined(tokenContract)) {
return tokenContract;
}
// TODO(albrow): Do we really still need this check? The default error
// looks okay to me.
const doesContractExist = await this._web3Wrapper.doesContractExistAtAddressAsync(tokenAddress);
if (!doesContractExist) {
throw new Error(ContractWrappersError.ERC721TokenContractDoesNotExist);
}
const contractInstance = new ERC721TokenContract(
this.abi,
normalizedTokenAddress,

7
packages/contract-wrappers/src/contract_wrappers/ether_token_wrapper.ts
View File

@@ -197,13 +197,6 @@ export class EtherTokenWrapper extends ContractWrapper {
if (!_.isUndefined(etherTokenContract)) {
return etherTokenContract;
}
// TODO(albrow): Do we really still need this check? The default error
// looks okay to me.
// TODO(albrow): Should we normalize the token address here?
const doesContractExist = await this._web3Wrapper.doesContractExistAtAddressAsync(etherTokenAddress);
if (!doesContractExist) {
throw new Error(ContractWrappersError.EtherTokenContractDoesNotExist);
}
const contractInstance = new WETH9Contract(
this.abi,
etherTokenAddress,

7
packages/contract-wrappers/src/types.ts
View File

@@ -19,13 +19,6 @@ export enum ExchangeWrapperError {
}
export enum ContractWrappersError {
ExchangeContractDoesNotExist = 'EXCHANGE_CONTRACT_DOES_NOT_EXIST',
ZRXContractDoesNotExist = 'ZRX_CONTRACT_DOES_NOT_EXIST',
EtherTokenContractDoesNotExist = 'ETHER_TOKEN_CONTRACT_DOES_NOT_EXIST',
ERC20ProxyContractDoesNotExist = 'ERC20_PROXY_CONTRACT_DOES_NOT_EXIST',
ERC721ProxyContractDoesNotExist = 'ERC721_PROXY_CONTRACT_DOES_NOT_EXIST',
ERC20TokenContractDoesNotExist = 'ERC20_TOKEN_CONTRACT_DOES_NOT_EXIST',
ERC721TokenContractDoesNotExist = 'ERC721_TOKEN_CONTRACT_DOES_NOT_EXIST',
ContractNotDeployedOnNetwork = 'CONTRACT_NOT_DEPLOYED_ON_NETWORK',
InsufficientAllowanceForTransfer = 'INSUFFICIENT_ALLOWANCE_FOR_TRANSFER',
InsufficientBalanceForTransfer = 'INSUFFICIENT_BALANCE_FOR_TRANSFER',

33
packages/contract-wrappers/test/erc20_wrapper_test.ts
View File

@@ -80,19 +80,6 @@ describe('ERC20Wrapper', () => {
contractWrappers.erc20Token.transferAsync(tokenAddress, fromAddress, toAddress, transferAmount),
).to.be.rejectedWith(ContractWrappersError.InsufficientBalanceForTransfer);
});
it('should throw a CONTRACT_DOES_NOT_EXIST error for a non-existent token contract', async () => {
const nonExistentTokenAddress = '0x9dd402f14d67e001d8efbe6583e51bf9706aa065';
const fromAddress = coinbase;
const toAddress = coinbase;
return expect(
contractWrappers.erc20Token.transferAsync(
nonExistentTokenAddress,
fromAddress,
toAddress,
transferAmount,
),
).to.be.rejectedWith(ContractWrappersError.ERC20TokenContractDoesNotExist);
});
});
describe('#transferFromAsync', () => {
let tokenAddress: string;
@@ -197,19 +184,6 @@ describe('ERC20Wrapper', () => {
const postBalance = await contractWrappers.erc20Token.getBalanceAsync(tokenAddress, toAddress);
return expect(postBalance).to.be.bignumber.equal(transferAmount);
});
it('should throw a CONTRACT_DOES_NOT_EXIST error for a non-existent token contract', async () => {
const fromAddress = coinbase;
const nonExistentTokenAddress = '0x9dd402f14d67e001d8efbe6583e51bf9706aa065';
return expect(
contractWrappers.erc20Token.transferFromAsync(
nonExistentTokenAddress,
fromAddress,
toAddress,
senderAddress,
new BigNumber(42),
),
).to.be.rejectedWith(ContractWrappersError.ERC20TokenContractDoesNotExist);
});
});
describe('#getBalanceAsync', () => {
describe('With provider with accounts', () => {
@@ -220,13 +194,6 @@ describe('ERC20Wrapper', () => {
const expectedBalance = new BigNumber('1000000000000000000000000000');
return expect(balance).to.be.bignumber.equal(expectedBalance);
});
it('should throw a CONTRACT_DOES_NOT_EXIST error for a non-existent token contract', async () => {
const nonExistentTokenAddress = '0x9dd402f14d67e001d8efbe6583e51bf9706aa065';
const ownerAddress = coinbase;
return expect(
contractWrappers.erc20Token.getBalanceAsync(nonExistentTokenAddress, ownerAddress),
).to.be.rejectedWith(ContractWrappersError.ERC20TokenContractDoesNotExist);
});
it('should return a balance of 0 for a non-existent owner address', async () => {
const tokenAddress = tokens[0];
const nonExistentOwner = '0x198c6ad858f213fb31b6fe809e25040e6b964593';

13
packages/contract-wrappers/test/erc721_wrapper_test.ts
View File

@@ -115,12 +115,6 @@ describe('ERC721Wrapper', () => {
tokenCount = await contractWrappers.erc721Token.getTokenCountAsync(tokenAddress, ownerAddress);
expect(tokenCount).to.be.bignumber.equal(1);
});
it('should throw a CONTRACT_DOES_NOT_EXIST error for a non-existent token contract', async () => {
const nonExistentTokenAddress = '0x9dd402f14d67e001d8efbe6583e51bf9706aa065';
return expect(
contractWrappers.erc721Token.getTokenCountAsync(nonExistentTokenAddress, ownerAddress),
).to.be.rejectedWith(ContractWrappersError.ERC721TokenContractDoesNotExist);
});
it('should return a balance of 0 for a non-existent owner address', async () => {
const nonExistentOwner = '0x198c6ad858f213fb31b6fe809e25040e6b964593';
const balance = await contractWrappers.erc721Token.getTokenCountAsync(tokenAddress, nonExistentOwner);
@@ -149,13 +143,6 @@ describe('ERC721Wrapper', () => {
const tokenOwner = await contractWrappers.erc721Token.getOwnerOfAsync(tokenAddress, tokenId);
expect(tokenOwner).to.be.bignumber.equal(ownerAddress);
});
it('should throw a CONTRACT_DOES_NOT_EXIST error for a non-existent token contract', async () => {
const nonExistentTokenAddress = '0x9dd402f14d67e001d8efbe6583e51bf9706aa065';
const fakeTokenId = new BigNumber(42);
return expect(
contractWrappers.erc721Token.getOwnerOfAsync(nonExistentTokenAddress, fakeTokenId),
).to.be.rejectedWith(ContractWrappersError.ERC721TokenContractDoesNotExist);
});
it('should return undefined not 0 for a non-existent ERC721', async () => {
const fakeTokenId = new BigNumber(42);
return expect(contractWrappers.erc721Token.getOwnerOfAsync(tokenAddress, fakeTokenId)).to.be.rejectedWith(