aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--src/contract_wrappers/token_wrapper.ts89
-rw-r--r--src/globals.d.ts6
-rw-r--r--src/types.ts6
-rw-r--r--src/utils/assert.ts6
-rw-r--r--src/web3_wrapper.ts12
-rw-r--r--test/token_wrapper_test.ts169
6 files changed, 240 insertions, 48 deletions
diff --git a/src/contract_wrappers/token_wrapper.ts b/src/contract_wrappers/token_wrapper.ts
index 69bcc9024..c8b557d0d 100644
--- a/src/contract_wrappers/token_wrapper.ts
+++ b/src/contract_wrappers/token_wrapper.ts
@@ -33,21 +33,52 @@ export class TokenWrapper extends ContractWrapper {
return balance;
}
/**
- * Retrieves the allowance in baseUnits of the ERC20 token set to the 0x proxy contract
- * by an owner address.
+ * Sets the spender's allowance to a specified number of baseUnits on behalf of the owner address.
+ * Equivalent to the ERC20 spec method `approve`.
*/
- public async getProxyAllowanceAsync(tokenAddress: string, ownerAddress: string) {
+ public async setAllowanceAsync(tokenAddress: string, ownerAddress: string, spenderAddress: string,
+ amountInBaseUnits: BigNumber.BigNumber): Promise<void> {
assert.isETHAddressHex('ownerAddress', ownerAddress);
+ assert.isETHAddressHex('spenderAddress', spenderAddress);
assert.isETHAddressHex('tokenAddress', tokenAddress);
+ assert.isBigNumber('amountInBaseUnits', amountInBaseUnits);
const tokenContract = await this.getTokenContractAsync(tokenAddress);
- const proxyAddress = await this.getProxyAddressAsync();
- let allowanceInBaseUnits = await tokenContract.allowance.call(ownerAddress, proxyAddress);
+ // Hack: for some reason default estimated gas amount causes `base fee exceeds gas limit` exception
+ // on testrpc. Probably related to https://github.com/ethereumjs/testrpc/issues/294
+ // TODO: Debug issue in testrpc and submit a PR, then remove this hack
+ const networkIdIfExists = await this.web3Wrapper.getNetworkIdIfExistsAsync();
+ const gas = networkIdIfExists === constants.TESTRPC_NETWORK_ID ? ALLOWANCE_TO_ZERO_GAS_AMOUNT : undefined;
+ await tokenContract.approve(spenderAddress, amountInBaseUnits, {
+ from: ownerAddress,
+ gas,
+ });
+ }
+ /**
+ * Retrieves the owners allowance in baseUnits set to the spender's address.
+ */
+ public async getAllowanceAsync(tokenAddress: string, ownerAddress: string, spenderAddress: string) {
+ assert.isETHAddressHex('ownerAddress', ownerAddress);
+ assert.isETHAddressHex('tokenAddress', tokenAddress);
+
+ const tokenContract = await this.getTokenContractAsync(tokenAddress);
+ let allowanceInBaseUnits = await tokenContract.allowance.call(ownerAddress, spenderAddress);
// Wrap BigNumbers returned from web3 with our own (later) version of BigNumber
allowanceInBaseUnits = new BigNumber(allowanceInBaseUnits);
return allowanceInBaseUnits;
}
/**
+ * Retrieves the owner's allowance in baseUnits set to the 0x proxy contract.
+ */
+ public async getProxyAllowanceAsync(tokenAddress: string, ownerAddress: string) {
+ assert.isETHAddressHex('ownerAddress', ownerAddress);
+ assert.isETHAddressHex('tokenAddress', tokenAddress);
+
+ const proxyAddress = await this.getProxyAddressAsync();
+ const allowanceInBaseUnits = await this.getAllowanceAsync(tokenAddress, ownerAddress, proxyAddress);
+ return allowanceInBaseUnits;
+ }
+ /**
* Sets the 0x proxy contract's allowance to a specified number of a tokens' baseUnits on behalf
* of an owner address.
*/
@@ -57,17 +88,8 @@ export class TokenWrapper extends ContractWrapper {
assert.isETHAddressHex('tokenAddress', tokenAddress);
assert.isBigNumber('amountInBaseUnits', amountInBaseUnits);
- const tokenContract = await this.getTokenContractAsync(tokenAddress);
const proxyAddress = await this.getProxyAddressAsync();
- // Hack: for some reason default estimated gas amount causes `base fee exceeds gas limit` exception
- // on testrpc. Probably related to https://github.com/ethereumjs/testrpc/issues/294
- // TODO: Debug issue in testrpc and submit a PR, then remove this hack
- const networkIdIfExists = await this.web3Wrapper.getNetworkIdIfExistsAsync();
- const gas = networkIdIfExists === constants.TESTRPC_NETWORK_ID ? ALLOWANCE_TO_ZERO_GAS_AMOUNT : undefined;
- await tokenContract.approve(proxyAddress, amountInBaseUnits, {
- from: ownerAddress,
- gas,
- });
+ await this.setAllowanceAsync(tokenAddress, ownerAddress, proxyAddress, amountInBaseUnits);
}
/**
* Transfers `amountInBaseUnits` ERC20 tokens from `fromAddress` to `toAddress`.
@@ -80,10 +102,47 @@ export class TokenWrapper extends ContractWrapper {
assert.isBigNumber('amountInBaseUnits', amountInBaseUnits);
const tokenContract = await this.getTokenContractAsync(tokenAddress);
+
+ const fromAddressBalance = await this.getBalanceAsync(tokenAddress, fromAddress);
+ if (fromAddressBalance.lessThan(amountInBaseUnits)) {
+ throw new Error(ZeroExError.INSUFFICIENT_BALANCE_FOR_TRANSFER);
+ }
+
await tokenContract.transfer(toAddress, amountInBaseUnits, {
from: fromAddress,
});
}
+ /**
+ * Transfers `amountInBaseUnits` ERC20 tokens from `fromAddress` to `toAddress`.
+ * Requires the fromAddress to have sufficient funds and to have approved an allowance of
+ * `amountInBaseUnits` for senderAddress.
+ */
+ public async transferFromAsync(tokenAddress: string, fromAddress: string, toAddress: string,
+ senderAddress: string, amountInBaseUnits: BigNumber.BigNumber):
+ Promise<void> {
+ assert.isETHAddressHex('tokenAddress', tokenAddress);
+ assert.isETHAddressHex('fromAddress', fromAddress);
+ assert.isETHAddressHex('toAddress', toAddress);
+ assert.isETHAddressHex('senderAddress', senderAddress);
+ assert.isBigNumber('amountInBaseUnits', amountInBaseUnits);
+ await assert.isSenderAddressAvailableAsync(this.web3Wrapper, senderAddress);
+
+ const tokenContract = await this.getTokenContractAsync(tokenAddress);
+
+ const fromAddressAllowance = await this.getAllowanceAsync(tokenAddress, fromAddress, senderAddress);
+ if (fromAddressAllowance.lessThan(amountInBaseUnits)) {
+ throw new Error(ZeroExError.INSUFFICIENT_ALLOWANCE_FOR_TRANSFER);
+ }
+
+ const fromAddressBalance = await this.getBalanceAsync(tokenAddress, fromAddress);
+ if (fromAddressBalance.lessThan(amountInBaseUnits)) {
+ throw new Error(ZeroExError.INSUFFICIENT_BALANCE_FOR_TRANSFER);
+ }
+
+ await tokenContract.transferFrom(fromAddress, toAddress, amountInBaseUnits, {
+ from: senderAddress,
+ });
+ }
private async getTokenContractAsync(tokenAddress: string): Promise<TokenContract> {
let tokenContract = this.tokenContractsByAddress[tokenAddress];
if (!_.isUndefined(tokenContract)) {
diff --git a/src/globals.d.ts b/src/globals.d.ts
index d86f54dfc..164fc2386 100644
--- a/src/globals.d.ts
+++ b/src/globals.d.ts
@@ -14,6 +14,12 @@ declare interface Schema {
// disallow `namespace`, we disable tslint for the following.
/* tslint:disable */
declare namespace Chai {
+ interface NumberComparer {
+ (value: number|BigNumber.BigNumber, message?: string): Assertion;
+ }
+ interface NumericComparison {
+ greaterThan: NumberComparer;
+ }
interface Assertion {
bignumber: Assertion;
// HACK: In order to comply with chai-as-promised we make eventually a `PromisedAssertion` not an `Assertion`
diff --git a/src/types.ts b/src/types.ts
index 46156b155..9d3127325 100644
--- a/src/types.ts
+++ b/src/types.ts
@@ -16,6 +16,8 @@ export const ZeroExError = strEnum([
'INVALID_SIGNATURE',
'CONTRACT_NOT_DEPLOYED_ON_NETWORK',
'ZRX_NOT_IN_TOKEN_REGISTRY',
+ 'INSUFFICIENT_ALLOWANCE_FOR_TRANSFER',
+ 'INSUFFICIENT_BALANCE_FOR_TRANSFER',
]);
export type ZeroExError = keyof typeof ZeroExError;
@@ -66,7 +68,9 @@ export interface TokenContract {
allowance: {
call: (ownerAddress: string, allowedAddress: string) => Promise<BigNumber.BigNumber>;
};
- transfer: (to: string, amountInBaseUnits: BigNumber.BigNumber, txOpts: TxOpts) => Promise<boolean>;
+ transfer: (toAddress: string, amountInBaseUnits: BigNumber.BigNumber, txOpts: TxOpts) => Promise<boolean>;
+ transferFrom: (fromAddress: string, toAddress: string, amountInBaseUnits: BigNumber.BigNumber,
+ txOpts: TxOpts) => Promise<boolean>;
approve: (proxyAddress: string, amountInBaseUnits: BigNumber.BigNumber, txOpts: TxOpts) => void;
}
diff --git a/src/utils/assert.ts b/src/utils/assert.ts
index 406f2b149..5a31e1b16 100644
--- a/src/utils/assert.ts
+++ b/src/utils/assert.ts
@@ -1,6 +1,7 @@
import * as _ from 'lodash';
import * as BigNumber from 'bignumber.js';
import * as Web3 from 'web3';
+import {Web3Wrapper} from '../web3_wrapper';
import {SchemaValidator} from './schema_validator';
import {utils} from './utils';
@@ -25,6 +26,11 @@ export const assert = {
const web3 = new Web3();
this.assert(web3.isAddress(value), this.typeAssertionMessage(variableName, 'ETHAddressHex', value));
},
+ async isSenderAddressAvailableAsync(web3Wrapper: Web3Wrapper, senderAddress: string) {
+ const isSenderAddressAvailable = await web3Wrapper.isSenderAddressAvailableAsync(senderAddress);
+ assert.assert(isSenderAddressAvailable, 'Specified senderAddress isn\'t available through the \
+ supplied web3 instance');
+ },
isNumber(variableName: string, value: number): void {
this.assert(_.isFinite(value), this.typeAssertionMessage(variableName, 'number', value));
},
diff --git a/src/web3_wrapper.ts b/src/web3_wrapper.ts
index 49bd8b67d..9892abcb8 100644
--- a/src/web3_wrapper.ts
+++ b/src/web3_wrapper.ts
@@ -29,11 +29,15 @@ export class Web3Wrapper {
return senderAddressIfExists as string;
}
public async getFirstAddressIfExistsAsync(): Promise<string|undefined> {
- const addresses = await promisify(this.web3.eth.getAccounts)();
+ const addresses = await this.getAvailableSenderAddressesAsync();
if (_.isEmpty(addresses)) {
return undefined;
}
- return (addresses as string[])[0];
+ return addresses[0];
+ }
+ public async isSenderAddressAvailableAsync(senderAddress: string): Promise<boolean> {
+ const addresses = await this.getAvailableSenderAddressesAsync();
+ return _.includes(addresses, senderAddress);
}
public async getNodeVersionAsync(): Promise<string> {
const nodeVersion = await promisify(this.web3.version.getNode)();
@@ -77,6 +81,10 @@ export class Web3Wrapper {
const firstAccount = await this.getFirstAddressIfExistsAsync();
return firstAccount;
}
+ private async getAvailableSenderAddressesAsync(): Promise<string[]> {
+ const addresses: string[] = await promisify(this.web3.eth.getAccounts)();
+ return addresses;
+ }
private async getNetworkAsync(): Promise<number> {
const networkId = await promisify(this.web3.version.getNetwork)();
return networkId;
diff --git a/test/token_wrapper_test.ts b/test/token_wrapper_test.ts
index cfd87da84..698ad5b6a 100644
--- a/test/token_wrapper_test.ts
+++ b/test/token_wrapper_test.ts
@@ -17,11 +17,15 @@ describe('TokenWrapper', () => {
let zeroEx: ZeroEx;
let userAddresses: string[];
let tokens: Token[];
+ let coinbase: string;
+ let addressWithoutFunds: string;
before(async () => {
web3 = web3Factory.create();
zeroEx = new ZeroEx(web3);
userAddresses = await promisify(web3.eth.getAccounts)();
tokens = await zeroEx.tokenRegistry.getTokensAsync();
+ coinbase = userAddresses[0];
+ addressWithoutFunds = userAddresses[1];
});
beforeEach(async () => {
await blockchainLifecycle.startAsync();
@@ -30,85 +34,190 @@ describe('TokenWrapper', () => {
await blockchainLifecycle.revertAsync();
});
describe('#transferAsync', () => {
+ let token: Token;
+ let transferAmount: BigNumber.BigNumber;
+ before(() => {
+ token = tokens[0];
+ transferAmount = new BigNumber(42);
+ });
it('should successfully transfer tokens', async () => {
- const token = tokens[0];
- const fromAddress = userAddresses[0];
- const toAddress = userAddresses[1];
+ const fromAddress = coinbase;
+ const toAddress = addressWithoutFunds;
const preBalance = await zeroEx.token.getBalanceAsync(token.address, toAddress);
expect(preBalance).to.be.bignumber.equal(0);
- const transferAmount = new BigNumber(42);
await zeroEx.token.transferAsync(token.address, fromAddress, toAddress, transferAmount);
const postBalance = await zeroEx.token.getBalanceAsync(token.address, toAddress);
- expect(postBalance).to.be.bignumber.equal(transferAmount);
+ return expect(postBalance).to.be.bignumber.equal(transferAmount);
+ });
+ it('should fail to transfer tokens if fromAddress has an insufficient balance', async () => {
+ const fromAddress = addressWithoutFunds;
+ const toAddress = coinbase;
+ return expect(zeroEx.token.transferAsync(
+ token.address, fromAddress, toAddress, transferAmount,
+ )).to.be.rejectedWith(ZeroExError.INSUFFICIENT_BALANCE_FOR_TRANSFER);
});
it('should throw a CONTRACT_DOES_NOT_EXIST error for a non-existent token contract', async () => {
const nonExistentTokenAddress = '0x9dd402f14d67e001d8efbe6583e51bf9706aa065';
- const fromAddress = userAddresses[0];
- const toAddress = userAddresses[0];
- expect(zeroEx.token.transferAsync(
- nonExistentTokenAddress, fromAddress, toAddress, new BigNumber(42),
+ const fromAddress = coinbase;
+ const toAddress = coinbase;
+ return expect(zeroEx.token.transferAsync(
+ nonExistentTokenAddress, fromAddress, toAddress, transferAmount,
+ )).to.be.rejectedWith(ZeroExError.CONTRACT_DOES_NOT_EXIST);
+ });
+ });
+ describe('#transferFromAsync', () => {
+ let token: Token;
+ let toAddress: string;
+ let senderAddress: string;
+ before(async () => {
+ token = tokens[0];
+ toAddress = addressWithoutFunds;
+ senderAddress = userAddresses[2];
+ });
+ it('should fail to transfer tokens if fromAddress has insufficient allowance set', async () => {
+ const fromAddress = coinbase;
+ const transferAmount = new BigNumber(42);
+
+ const fromAddressBalance = await zeroEx.token.getBalanceAsync(token.address, fromAddress);
+ expect(fromAddressBalance).to.be.bignumber.greaterThan(transferAmount);
+
+ const fromAddressAllowance = await zeroEx.token.getAllowanceAsync(token.address, fromAddress,
+ toAddress);
+ expect(fromAddressAllowance).to.be.bignumber.equal(0);
+
+ return expect(zeroEx.token.transferFromAsync(
+ token.address, fromAddress, toAddress, senderAddress, transferAmount,
+ )).to.be.rejectedWith(ZeroExError.INSUFFICIENT_ALLOWANCE_FOR_TRANSFER);
+ });
+ it('should fail to transfer tokens if fromAddress has insufficient balance', async () => {
+ const fromAddress = addressWithoutFunds;
+ const transferAmount = new BigNumber(42);
+
+ const fromAddressBalance = await zeroEx.token.getBalanceAsync(token.address, fromAddress);
+ expect(fromAddressBalance).to.be.bignumber.equal(0);
+
+ await zeroEx.token.setAllowanceAsync(token.address, fromAddress, senderAddress, transferAmount);
+ const fromAddressAllowance = await zeroEx.token.getAllowanceAsync(token.address, fromAddress,
+ senderAddress);
+ expect(fromAddressAllowance).to.be.bignumber.equal(transferAmount);
+
+ return expect(zeroEx.token.transferFromAsync(
+ token.address, fromAddress, toAddress, senderAddress, transferAmount,
+ )).to.be.rejectedWith(ZeroExError.INSUFFICIENT_BALANCE_FOR_TRANSFER);
+ });
+ it('should successfully transfer tokens', async () => {
+ const fromAddress = coinbase;
+
+ const preBalance = await zeroEx.token.getBalanceAsync(token.address, toAddress);
+ expect(preBalance).to.be.bignumber.equal(0);
+
+ const transferAmount = new BigNumber(42);
+ await zeroEx.token.setAllowanceAsync(token.address, fromAddress, senderAddress, transferAmount);
+
+ await zeroEx.token.transferFromAsync(token.address, fromAddress, toAddress, senderAddress,
+ transferAmount);
+ const postBalance = await zeroEx.token.getBalanceAsync(token.address, 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(zeroEx.token.transferFromAsync(
+ nonExistentTokenAddress, fromAddress, toAddress, senderAddress, new BigNumber(42),
)).to.be.rejectedWith(ZeroExError.CONTRACT_DOES_NOT_EXIST);
});
});
describe('#getBalanceAsync', () => {
it('should return the balance for an existing ERC20 token', async () => {
const token = tokens[0];
- const ownerAddress = userAddresses[0];
+ const ownerAddress = coinbase;
const balance = await zeroEx.token.getBalanceAsync(token.address, ownerAddress);
const expectedBalance = new BigNumber('100000000000000000000000000');
- expect(balance).to.be.bignumber.equal(expectedBalance);
+ 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 = userAddresses[0];
- expect(zeroEx.token.getBalanceAsync(nonExistentTokenAddress, ownerAddress))
+ const ownerAddress = coinbase;
+ return expect(zeroEx.token.getBalanceAsync(nonExistentTokenAddress, ownerAddress))
.to.be.rejectedWith(ZeroExError.CONTRACT_DOES_NOT_EXIST);
});
it('should return a balance of 0 for a non-existent owner address', async () => {
const token = tokens[0];
const nonExistentOwner = '0x198C6Ad858F213Fb31b6FE809E25040E6B964593';
const balance = await zeroEx.token.getBalanceAsync(token.address, nonExistentOwner);
- const expectedBalance = new BigNumber('0');
- expect(balance).to.be.bignumber.equal(expectedBalance);
+ const expectedBalance = new BigNumber(0);
+ return expect(balance).to.be.bignumber.equal(expectedBalance);
});
});
- describe('#getProxyAllowanceAsync', () => {
+ describe('#setAllowanceAsync', () => {
+ it('should set the spender\'s allowance', async () => {
+ const token = tokens[0];
+ const ownerAddress = coinbase;
+ const spenderAddress = addressWithoutFunds;
+
+ const allowanceBeforeSet = await zeroEx.token.getAllowanceAsync(token.address, ownerAddress,
+ spenderAddress);
+ const expectedAllowanceBeforeAllowanceSet = new BigNumber(0);
+ expect(allowanceBeforeSet).to.be.bignumber.equal(expectedAllowanceBeforeAllowanceSet);
+
+ const amountInBaseUnits = new BigNumber(50);
+ await zeroEx.token.setAllowanceAsync(token.address, ownerAddress, spenderAddress, amountInBaseUnits);
+
+ const allowanceAfterSet = await zeroEx.token.getAllowanceAsync(token.address, ownerAddress, spenderAddress);
+ const expectedAllowanceAfterAllowanceSet = amountInBaseUnits;
+ return expect(allowanceAfterSet).to.be.bignumber.equal(expectedAllowanceAfterAllowanceSet);
+ });
+ });
+ describe('#getAllowanceAsync', () => {
it('should get the proxy allowance', async () => {
const token = tokens[0];
- const ownerAddress = userAddresses[0];
+ const ownerAddress = coinbase;
+ const spenderAddress = addressWithoutFunds;
- const amountInUnits = new BigNumber('50');
- const amountInBaseUnits = ZeroEx.toBaseUnitAmount(amountInUnits, token.decimals);
- await zeroEx.token.setProxyAllowanceAsync(token.address, ownerAddress, amountInBaseUnits);
+ const amountInBaseUnits = new BigNumber(50);
+ await zeroEx.token.setAllowanceAsync(token.address, ownerAddress, spenderAddress, amountInBaseUnits);
- const allowance = await zeroEx.token.getProxyAllowanceAsync(token.address, ownerAddress);
+ const allowance = await zeroEx.token.getAllowanceAsync(token.address, ownerAddress, spenderAddress);
const expectedAllowance = amountInBaseUnits;
- expect(allowance).to.be.bignumber.equal(expectedAllowance);
+ return expect(allowance).to.be.bignumber.equal(expectedAllowance);
});
it('should return 0 if no allowance set yet', async () => {
const token = tokens[0];
- const ownerAddress = userAddresses[0];
+ const ownerAddress = coinbase;
+ const spenderAddress = addressWithoutFunds;
+ const allowance = await zeroEx.token.getAllowanceAsync(token.address, ownerAddress, spenderAddress);
+ const expectedAllowance = new BigNumber(0);
+ return expect(allowance).to.be.bignumber.equal(expectedAllowance);
+ });
+ });
+ describe('#getProxyAllowanceAsync', () => {
+ it('should get the proxy allowance', async () => {
+ const token = tokens[0];
+ const ownerAddress = coinbase;
+
+ const amountInBaseUnits = new BigNumber(50);
+ await zeroEx.token.setProxyAllowanceAsync(token.address, ownerAddress, amountInBaseUnits);
+
const allowance = await zeroEx.token.getProxyAllowanceAsync(token.address, ownerAddress);
- const expectedAllowance = new BigNumber('0');
- expect(allowance).to.be.bignumber.equal(expectedAllowance);
+ const expectedAllowance = amountInBaseUnits;
+ return expect(allowance).to.be.bignumber.equal(expectedAllowance);
});
});
describe('#setProxyAllowanceAsync', () => {
it('should set the proxy allowance', async () => {
const token = tokens[0];
- const ownerAddress = userAddresses[0];
+ const ownerAddress = coinbase;
const allowanceBeforeSet = await zeroEx.token.getProxyAllowanceAsync(token.address, ownerAddress);
- const expectedAllowanceBeforeAllowanceSet = new BigNumber('0');
+ const expectedAllowanceBeforeAllowanceSet = new BigNumber(0);
expect(allowanceBeforeSet).to.be.bignumber.equal(expectedAllowanceBeforeAllowanceSet);
- const amountInUnits = new BigNumber('50');
- const amountInBaseUnits = ZeroEx.toBaseUnitAmount(amountInUnits, token.decimals);
+ const amountInBaseUnits = new BigNumber(50);
await zeroEx.token.setProxyAllowanceAsync(token.address, ownerAddress, amountInBaseUnits);
const allowanceAfterSet = await zeroEx.token.getProxyAllowanceAsync(token.address, ownerAddress);
const expectedAllowanceAfterAllowanceSet = amountInBaseUnits;
- expect(allowanceAfterSet).to.be.bignumber.equal(expectedAllowanceAfterAllowanceSet);
+ return expect(allowanceAfterSet).to.be.bignumber.equal(expectedAllowanceAfterAllowanceSet);
});
});
});
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-10 13:28:07 +0800