aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--src/0x.ts7
-rw-r--r--src/contract_wrappers/ether_token_wrapper.ts76
-rw-r--r--src/types.ts8
-rw-r--r--src/web3_wrapper.ts4
-rw-r--r--test/ether_token_wrapper_test.ts99
5 files changed, 194 insertions, 0 deletions
diff --git a/src/0x.ts b/src/0x.ts
index 3a06c7b5a..d7a01ba70 100644
--- a/src/0x.ts
+++ b/src/0x.ts
@@ -12,6 +12,7 @@ import {utils} from './utils/utils';
import {assert} from './utils/assert';
import {ExchangeWrapper} from './contract_wrappers/exchange_wrapper';
import {TokenRegistryWrapper} from './contract_wrappers/token_registry_wrapper';
+import {EtherTokenWrapper} from './contract_wrappers/ether_token_wrapper';
import {ecSignatureSchema} from './schemas/ec_signature_schema';
import {TokenWrapper} from './contract_wrappers/token_wrapper';
import {ECSignature, ZeroExError, Order, SignedOrder, Web3Provider} from './types';
@@ -46,6 +47,11 @@ export class ZeroEx {
* An instance of the TokenWrapper class containing methods for interacting with any ERC20 token smart contract.
*/
public token: TokenWrapper;
+ /**
+ * An instance of the EtherTokenWrapper class containing methods for interacting with the
+ * wrapped ETH ERC20 token smart contract.
+ */
+ public etherToken: EtherTokenWrapper;
private _web3Wrapper: Web3Wrapper;
/**
* Verifies that the elliptic curve signature `signature` was generated
@@ -145,6 +151,7 @@ export class ZeroEx {
this.token = new TokenWrapper(this._web3Wrapper);
this.exchange = new ExchangeWrapper(this._web3Wrapper, this.token);
this.tokenRegistry = new TokenRegistryWrapper(this._web3Wrapper);
+ this.etherToken = new EtherTokenWrapper(this._web3Wrapper, this.token);
}
/**
* Sets a new provider for the web3 instance used by 0x.js. Updating the provider will stop all
diff --git a/src/contract_wrappers/ether_token_wrapper.ts b/src/contract_wrappers/ether_token_wrapper.ts
new file mode 100644
index 000000000..e2ef0270d
--- /dev/null
+++ b/src/contract_wrappers/ether_token_wrapper.ts
@@ -0,0 +1,76 @@
+import * as _ from 'lodash';
+import {Web3Wrapper} from '../web3_wrapper';
+import {ContractWrapper} from './contract_wrapper';
+import {TokenWrapper} from './token_wrapper';
+import {EtherTokenContract, ZeroExError} from '../types';
+import {assert} from '../utils/assert';
+import * as EtherTokenArtifacts from '../artifacts/EtherToken.json';
+
+/**
+ * This class includes all the functionality related to interacting with a wrapped Ether ERC20 token contract.
+ * The caller can convert ETH into the equivalent number of wrapped ETH ERC20 tokens and back.
+ */
+export class EtherTokenWrapper extends ContractWrapper {
+ private _etherTokenContractIfExists?: EtherTokenContract;
+ private _tokenWrapper: TokenWrapper;
+ constructor(web3Wrapper: Web3Wrapper, tokenWrapper: TokenWrapper) {
+ super(web3Wrapper);
+ this._tokenWrapper = tokenWrapper;
+ }
+ /**
+ * Deposit ETH into the Wrapped ETH smart contract and issues the equivalent number of wrapped ETH tokens
+ * to the depositor address. These wrapped ETH tokens can be used in 0x trades and are redeemable for 1-to-1
+ * for ETH.
+ * @param amountInWei Amount of ETH in Wei the caller wishes to deposit.
+ * @param depositor The hex encoded user Ethereum address that would like to make the deposit.
+ */
+ public async depositAsync(amountInWei: BigNumber.BigNumber, depositor: string): Promise<void> {
+ assert.isBigNumber('amountInWei', amountInWei);
+ await assert.isSenderAddressAsync('depositor', depositor, this._web3Wrapper);
+
+ const ethBalance = await this._web3Wrapper.getBalanceInEthAsync(depositor);
+ const ethBalanceInWei = this._web3Wrapper.toWei(ethBalance);
+ assert.assert(ethBalanceInWei.gte(amountInWei), ZeroExError.INSUFFICIENT_ETH_BALANCE_FOR_DEPOSIT);
+
+ const wethContract = await this._getEtherTokenContractAsync();
+ await wethContract.deposit({
+ from: depositor,
+ value: amountInWei,
+ });
+ }
+ /**
+ * Withdraw ETH to the withdrawer's address from the wrapped ETH smart contract in exchange for the
+ * equivalent number of wrapped ETH tokens.
+ * @param amountInWei Amount of ETH in Wei the caller wishes to withdraw.
+ * @param withdrawer The hex encoded user Ethereum address that would like to make the withdrawl.
+ */
+ public async withdrawAsync(amountInWei: BigNumber.BigNumber, withdrawer: string): Promise<void> {
+ assert.isBigNumber('amountInWei', amountInWei);
+ await assert.isSenderAddressAsync('withdrawer', withdrawer, this._web3Wrapper);
+
+ const wethContractAddress = await this.getContractAddressAsync();
+ const WETHBalanceInBaseUnits = await this._tokenWrapper.getBalanceAsync(wethContractAddress, withdrawer);
+ assert.assert(WETHBalanceInBaseUnits.gte(amountInWei), ZeroExError.INSUFFICIENT_WETH_BALANCE_FOR_WITHDRAWL);
+
+ const wethContract = await this._getEtherTokenContractAsync();
+ await wethContract.withdraw(amountInWei, {
+ from: withdrawer,
+ });
+ }
+ /**
+ * Retrieves the Wrapped Ether token contract address
+ * @return The Wrapped Ether token contract address
+ */
+ public async getContractAddressAsync(): Promise<string> {
+ const wethContract = await this._getEtherTokenContractAsync();
+ return wethContract.address;
+ }
+ private async _getEtherTokenContractAsync(): Promise<EtherTokenContract> {
+ if (!_.isUndefined(this._etherTokenContractIfExists)) {
+ return this._etherTokenContractIfExists;
+ }
+ const contractInstance = await this._instantiateContractIfExistsAsync((EtherTokenArtifacts as any));
+ this._etherTokenContractIfExists = contractInstance as EtherTokenContract;
+ return this._etherTokenContractIfExists;
+ }
+}
diff --git a/src/types.ts b/src/types.ts
index 2b7fba226..c21060e7f 100644
--- a/src/types.ts
+++ b/src/types.ts
@@ -19,6 +19,8 @@ export const ZeroExError = strEnum([
'ZRX_NOT_IN_TOKEN_REGISTRY',
'INSUFFICIENT_ALLOWANCE_FOR_TRANSFER',
'INSUFFICIENT_BALANCE_FOR_TRANSFER',
+ 'INSUFFICIENT_ETH_BALANCE_FOR_DEPOSIT',
+ 'INSUFFICIENT_WETH_BALANCE_FOR_WITHDRAWL',
'INVALID_JUMP',
'OUT_OF_GAS',
]);
@@ -140,6 +142,11 @@ export interface TokenRegistryContract extends ContractInstance {
};
}
+export interface EtherTokenContract extends ContractInstance {
+ deposit: (txOpts: TxOpts) => Promise<void>;
+ withdraw: (amount: BigNumber.BigNumber, txOpts: TxOpts) => Promise<void>;
+}
+
export const SolidityTypes = strEnum([
'address',
'uint256',
@@ -255,6 +262,7 @@ export interface Token {
export interface TxOpts {
from: string;
gas?: number;
+ value?: BigNumber.BigNumber;
}
export interface TokenAddressBySymbol {
diff --git a/src/web3_wrapper.ts b/src/web3_wrapper.ts
index afecbec7f..0a310aeee 100644
--- a/src/web3_wrapper.ts
+++ b/src/web3_wrapper.ts
@@ -34,6 +34,10 @@ export class Web3Wrapper {
return undefined;
}
}
+ public toWei(ethAmount: BigNumber.BigNumber): BigNumber.BigNumber {
+ const balanceWei = this.web3.toWei(ethAmount, 'ether');
+ return balanceWei;
+ }
public async getBalanceInEthAsync(owner: string): Promise<BigNumber.BigNumber> {
const balanceInWei = await promisify(this.web3.eth.getBalance)(owner);
let balanceEth = this.web3.fromWei(balanceInWei, 'ether');
diff --git a/test/ether_token_wrapper_test.ts b/test/ether_token_wrapper_test.ts
new file mode 100644
index 000000000..730b85497
--- /dev/null
+++ b/test/ether_token_wrapper_test.ts
@@ -0,0 +1,99 @@
+import 'mocha';
+import * as chai from 'chai';
+import {chaiSetup} from './utils/chai_setup';
+import * as Web3 from 'web3';
+import * as BigNumber from 'bignumber.js';
+import promisify = require('es6-promisify');
+import {web3Factory} from './utils/web3_factory';
+import {ZeroEx, ZeroExError, Token} from '../src';
+import {BlockchainLifecycle} from './utils/blockchain_lifecycle';
+
+chaiSetup.configure();
+const expect = chai.expect;
+const blockchainLifecycle = new BlockchainLifecycle();
+
+describe.only('EtherTokenWrapper', () => {
+ let web3: Web3;
+ let zeroEx: ZeroEx;
+ let userAddresses: string[];
+ let addressWithETH: string;
+ let wethContractAddress: string;
+ let depositETHAmount: BigNumber.BigNumber;
+ let depositWeiAmount: BigNumber.BigNumber;
+ let decimalPlaces: number;
+ before(async () => {
+ web3 = web3Factory.create();
+ zeroEx = new ZeroEx(web3.currentProvider);
+ userAddresses = await promisify(web3.eth.getAccounts)();
+ addressWithETH = userAddresses[0];
+ wethContractAddress = await zeroEx.etherToken.getContractAddressAsync();
+ depositETHAmount = new BigNumber(5);
+ depositWeiAmount = (zeroEx as any)._web3Wrapper.toWei(depositETHAmount);
+ decimalPlaces = 7;
+ });
+ beforeEach(async () => {
+ await blockchainLifecycle.startAsync();
+ });
+ afterEach(async () => {
+ await blockchainLifecycle.revertAsync();
+ });
+ describe('#depositAsync', () => {
+ it('should successfully deposit ETH and issue Wrapped ETH tokens', async () => {
+ const preETHBalance = await (zeroEx as any)._web3Wrapper.getBalanceInEthAsync(addressWithETH);
+ const preWETHBalance = await zeroEx.token.getBalanceAsync(wethContractAddress, addressWithETH);
+ expect(preETHBalance).to.be.bignumber.gt(0);
+ expect(preWETHBalance).to.be.bignumber.equal(0);
+
+ await zeroEx.etherToken.depositAsync(depositWeiAmount, addressWithETH);
+
+ const postETHBalance = await (zeroEx as any)._web3Wrapper.getBalanceInEthAsync(addressWithETH);
+ const postWETHBalanceInBaseUnits = await zeroEx.token.getBalanceAsync(wethContractAddress, addressWithETH);
+
+ expect(postWETHBalanceInBaseUnits).to.be.bignumber.equal(depositWeiAmount);
+ const remainingETH = preETHBalance.minus(depositETHAmount);
+ return expect(postETHBalance.round(decimalPlaces)).to.be.bignumber.equal(remainingETH);
+ });
+ it('should throw if user has insufficient ETH balance for deposit', async () => {
+ const preETHBalance = await (zeroEx as any)._web3Wrapper.getBalanceInEthAsync(addressWithETH);
+
+ const overETHBalance = preETHBalance.add(5);
+ const overETHBalanceinWei = (zeroEx as any)._web3Wrapper.toWei(overETHBalance);
+
+ return expect(
+ zeroEx.etherToken.depositAsync(overETHBalanceinWei, addressWithETH),
+ ).to.be.rejectedWith(ZeroExError.INSUFFICIENT_ETH_BALANCE_FOR_DEPOSIT);
+ });
+ });
+ describe('#withdrawAsync', () => {
+ it('should successfully withdraw ETH in return for Wrapped ETH tokens', async () => {
+ const ETHBalance = await (zeroEx as any)._web3Wrapper.getBalanceInEthAsync(addressWithETH);
+
+ await zeroEx.etherToken.depositAsync(depositWeiAmount, addressWithETH);
+
+ const expectedPreETHBalance = ETHBalance.minus(depositETHAmount);
+ const preETHBalance = await (zeroEx as any)._web3Wrapper.getBalanceInEthAsync(addressWithETH);
+ const preWETHBalance = await zeroEx.token.getBalanceAsync(wethContractAddress, addressWithETH);
+ expect(preETHBalance.round(decimalPlaces)).to.be.bignumber.equal(expectedPreETHBalance);
+ expect(preWETHBalance).to.be.bignumber.equal(depositWeiAmount);
+
+ await zeroEx.etherToken.withdrawAsync(depositWeiAmount, addressWithETH);
+
+ const postETHBalance = await (zeroEx as any)._web3Wrapper.getBalanceInEthAsync(addressWithETH);
+ const postWETHBalanceInBaseUnits = await zeroEx.token.getBalanceAsync(wethContractAddress, addressWithETH);
+
+ expect(postWETHBalanceInBaseUnits).to.be.bignumber.equal(0);
+ const expectedETHBalance = preETHBalance.add(depositETHAmount).round(decimalPlaces);
+ return expect(postETHBalance.round(decimalPlaces)).to.be.bignumber.equal(expectedETHBalance);
+ });
+ it('should throw if user has insufficient WETH balance for withdrawl', async () => {
+ const preWETHBalance = await zeroEx.token.getBalanceAsync(wethContractAddress, addressWithETH);
+ expect(preWETHBalance).to.be.bignumber.equal(0);
+
+ const overWETHBalance = preWETHBalance.add(999999999);
+
+ return expect(
+ zeroEx.etherToken.withdrawAsync(overWETHBalance, addressWithETH),
+ ).to.be.rejectedWith(ZeroExError.INSUFFICIENT_WETH_BALANCE_FOR_WITHDRAWL);
+ });
+ });
+});
generated by cgit v1.2.3 (git 2.25.1) at 2024-07-20 19:29:41 +0800