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

cleaning

Browse Source
This commit is contained in:
Greg Hysen 2018-12-03 17:18:34 -08:00
parent 8007ef6c0b
commit c040ad0850
2 changed files with 19 additions and 56 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

60
packages/contracts/contracts/extensions/CompliantForwarder/CompliantForwarder.sol
View File

@ -84,76 +84,36 @@ contract CompliantForwarder is ExchangeSelectors{
exchangeOffset := add(0x4, add(exchangeTxPtr, add(0x24, offset))) exchangeOffset := add(0x4, add(exchangeTxPtr, add(0x24, offset)))
} }
function toOrderOffset(offset, orderParamIndex) -> orderOffset { function exchangeCalldataload(offset) -> value {
let exchangeOffset := calldataload(
toExchangeCalldataOffset( value := calldataload(toExchangeCalldataOffset(offset, 0))
offset,
orderParamIndex
)
)
orderOffset := toExchangeCalldataOffset(exchangeOffset, orderParamIndex)
} }
// function readMakerFieldFromOrder()
/*
function readFieldFromOrder()
function readMakerFieldFromOrder()*/
function appendMakerAddressFromOrder(orderParamIndex) { function appendMakerAddressFromOrder(orderParamIndex) {
let makerAddress := calldataload(toOrderOffset(0 /* makerAddress is at 0'th field */, 0 /*order is 1st param*/)) let orderPtr := exchangeCalldataload(0)
let makerAddress := exchangeCalldataload(orderPtr)
addAddressToValidate(makerAddress) addAddressToValidate(makerAddress)
} }
function appendMakerAddressesFromOrderSet(orderSetParamIndex) -> one { function appendMakerAddressesFromOrderSet(orderSetParamIndex) -> one {
let orderSetPtr := calldataload(toExchangeCalldataOffset(0, 0))
let orderSetPtrCalldata := toExchangeCalldataOffset(add(orderSetPtr, 0x20), 0)
let orderSetLength := calldataload(toExchangeCalldataOffset(orderSetPtr, 0))
for {let orderPtrOffset := add(0x20, orderSetPtr)} lt(orderPtrOffset, add(0x20, add(orderSetPtr, mul(0x20, orderSetLength)))) {orderPtrOffset := add(0x20, orderPtrOffset)} {
let orderPtr := calldataload(toExchangeCalldataOffset(orderPtrOffset, 0))
let makerAddress := calldataload(add(orderSetPtrCalldata, orderPtr))
addAddressToValidate(makerAddress)
}
}
function exchangeCalldataload(offset) -> value {
value := calldataload(toExchangeCalldataOffset(offset, 0))
}
function appendMakerAddressesFromOrderSet2(orderSetParamIndex) -> one {
let orderSetPtr := exchangeCalldataload(0) let orderSetPtr := exchangeCalldataload(0)
let orderSetLength := exchangeCalldataload(orderSetPtr) let orderSetLength := exchangeCalldataload(orderSetPtr)
let orderSetElementPtr := add(orderSetPtr, 0x20)
for {let orderPtrOffset := add(0x20, orderSetPtr)} lt(orderPtrOffset, add(0x20, add(orderSetPtr, mul(0x20, orderSetLength)))) {orderPtrOffset := add(0x20, orderPtrOffset)} { let orderSetElementEndPtr := add(orderSetElementPtr, mul(orderSetLength, 0x20))
for {let orderPtrOffset := orderSetElementPtr} lt(orderPtrOffset, orderSetElementEndPtr) {orderPtrOffset := add(orderPtrOffset, 0x20)} {
let orderPtr := exchangeCalldataload(orderPtrOffset) let orderPtr := exchangeCalldataload(orderPtrOffset)
let makerAddress := exchangeCalldataload(add(orderSetPtr, add(0x20, orderPtr))) let makerAddress := exchangeCalldataload(add(orderPtr, orderSetElementPtr))
addAddressToValidate(makerAddress) addAddressToValidate(makerAddress)
} }
} }
/*
function appendMakerAddressFromOrderSet(paramIndex) {
let exchangeTxPtr := calldataload(0x44)
// Add 0x20 for length offset and 0x04 for selector offset
let orderPtrRelativeToExchangeTx := calldataload(add(0x4, add(exchangeTxPtr, 0x24))) // 0x60
let orderPtr := add(0x4,add(exchangeTxPtr, add(0x24, orderPtrRelativeToExchangeTx)))
let makerAddress := calldataload(orderPtr)
addAddressToValidate(makerAddress)
}
*/
// Extract addresses to validate // Extract addresses to validate
let exchangeTxPtr1 := calldataload(0x44) let exchangeTxPtr1 := calldataload(0x44)
let selector := and(calldataload(add(0x4, add(0x20, exchangeTxPtr1))), 0xffffffff00000000000000000000000000000000000000000000000000000000) let selector := and(calldataload(add(0x4, add(0x20, exchangeTxPtr1))), 0xffffffff00000000000000000000000000000000000000000000000000000000)
switch selector switch selector
case 0x297bb70b00000000000000000000000000000000000000000000000000000000 /* batchFillOrders */ case 0x297bb70b00000000000000000000000000000000000000000000000000000000 /* batchFillOrders */
{ {
one := appendMakerAddressesFromOrderSet2(0) one := appendMakerAddressesFromOrderSet(0)
} }
case 0x3c28d86100000000000000000000000000000000000000000000000000000000 /* matchOrders */ case 0x3c28d86100000000000000000000000000000000000000000000000000000000 /* matchOrders */
{ {

15
packages/contracts/test/extensions/compliant_forwarder.ts
View File

@ -206,11 +206,11 @@ describe.only(ContractName.CompliantForwarder, () => {
afterEach(async () => { afterEach(async () => {
await blockchainLifecycle.revertAsync(); await blockchainLifecycle.revertAsync();
}); });
describe('fillOrder', () => { describe.only('fillOrder', () => {
beforeEach(async () => { beforeEach(async () => {
erc20Balances = await erc20Wrapper.getBalancesAsync(); erc20Balances = await erc20Wrapper.getBalancesAsync();
}); });
it('should transfer the correct amounts when maker and taker are compliant', async () => { it.only('should transfer the correct amounts when maker and taker are compliant', async () => {
const txHash = await compliantForwarderInstance.executeTransaction.sendTransactionAsync( const txHash = await compliantForwarderInstance.executeTransaction.sendTransactionAsync(
compliantSignedFillOrderTx.salt, compliantSignedFillOrderTx.salt,
compliantSignedFillOrderTx.signerAddress, compliantSignedFillOrderTx.signerAddress,
@ -220,7 +220,10 @@ describe.only(ContractName.CompliantForwarder, () => {
const decoder = new LogDecoder(web3Wrapper); const decoder = new LogDecoder(web3Wrapper);
const tx = await decoder.getTxWithDecodedLogsAsync(txHash); const tx = await decoder.getTxWithDecodedLogsAsync(txHash);
console.log(JSON.stringify(tx, null, 4)); console.log(JSON.stringify(tx, null, 4));
const newBalances = await erc20Wrapper.getBalancesAsync(); console.log('****** MAKER ADDRESS = ', compliantSignedOrder.makerAddress);
/*const newBalances = await erc20Wrapper.getBalancesAsync();
const makerAssetFillAmount = takerAssetFillAmount const makerAssetFillAmount = takerAssetFillAmount
.times(compliantSignedOrder.makerAssetAmount) .times(compliantSignedOrder.makerAssetAmount)
.dividedToIntegerBy(compliantSignedOrder.takerAssetAmount); .dividedToIntegerBy(compliantSignedOrder.takerAssetAmount);
@ -250,7 +253,7 @@ describe.only(ContractName.CompliantForwarder, () => {
); );
expect(newBalances[feeRecipientAddress][zrxToken.address]).to.be.bignumber.equal( expect(newBalances[feeRecipientAddress][zrxToken.address]).to.be.bignumber.equal(
erc20Balances[feeRecipientAddress][zrxToken.address].add(makerFeePaid.add(takerFeePaid)), erc20Balances[feeRecipientAddress][zrxToken.address].add(makerFeePaid.add(takerFeePaid)),
); );*/
}); });
it('should revert if the signed transaction is not intended for fillOrder', async () => { it('should revert if the signed transaction is not intended for fillOrder', async () => {
// Create signed order without the fillOrder function selector // Create signed order without the fillOrder function selector
@ -335,11 +338,11 @@ describe.only(ContractName.CompliantForwarder, () => {
}); });
}); });
describe.only('batchFillOrders', () => { describe('batchFillOrders', () => {
beforeEach(async () => { beforeEach(async () => {
erc20Balances = await erc20Wrapper.getBalancesAsync(); erc20Balances = await erc20Wrapper.getBalancesAsync();
}); });
it.only ('should transfer the correct amounts when maker and taker are compliant', async () => { it('should transfer the correct amounts when maker and taker are compliant', async () => {
let order2 = _.cloneDeep(compliantSignedOrder); let order2 = _.cloneDeep(compliantSignedOrder);
order2.makerAddress = `0x${_.reverse(compliantSignedOrder.makerAddress.slice(2).split('')).join('')}`; order2.makerAddress = `0x${_.reverse(compliantSignedOrder.makerAddress.slice(2).split('')).join('')}`;
const orders = [compliantSignedOrder, order2]; const orders = [compliantSignedOrder, order2];