0x.js Tutorial on how to create, validate and fill an order

0x_Tutorial_1.js

const Web3      = require('web3');
const ZeroEx    = require('0x.js').ZeroEx;
const BigNumber = require('bignumber.js');

// Default provider for TestRPC
const provider = new Web3.providers.HttpProvider('http://localhost:8545')

// Calling constructor
const zeroEx = new ZeroEx(provider);


(async () => 
{
	//Number of decimals to use (for ETH and ZRX)
	const DECIMALS = 18; 

	// Addresses
	const NULL_ADDRESS = ZeroEx.NULL_ADDRESS;                                	 // Ethereum Null address
	const WETH_ADDRESS = await zeroEx.etherToken.getContractAddressAsync();  	 // The wrapped ETH token contract
	const ZRX_ADDRESS  = await zeroEx.exchange.getZRXTokenAddressAsync();    	 // The ZRX token contract
	const EXCHANGE_ADDRESS   = await zeroEx.exchange.getContractAddressAsync();  // The Exchange.sol address (0x exchange smart contract)

	//Getting list of accounts
	const accounts =  await zeroEx.getAvailableAddressesAsync();
	console.log(accounts)

	//Set our address
	const [makerAddress, takerAddress] = accounts;

	// Unlimited allowances to 0x contract for maker and taker
	const txHashAllowMaker = await zeroEx.token.setUnlimitedProxyAllowanceAsync(ZRX_ADDRESS,  makerAddress); 
	await zeroEx.awaitTransactionMinedAsync(txHashAllowMaker)
	console.log('Maker Allowance Mined...');

	const txHashAllowTaker = await zeroEx.token.setUnlimitedProxyAllowanceAsync(WETH_ADDRESS, takerAddress);
	await zeroEx.awaitTransactionMinedAsync(txHashAllowTaker)
	console.log('takerFee Allowance Mined...');

	//Deposit WETH
	const ethToConvert = ZeroEx.toBaseUnitAmount(new BigNumber(1), DECIMALS); // Number of ETH to convert to WETH

	const txHashWETH = await zeroEx.etherToken.depositAsync(ethToConvert, takerAddress);
	await zeroEx.awaitTransactionMinedAsync(txHashWETH)
	console.log('ETH -> WETH Mined...');

	// Generate order
	const order = { 
			maker: makerAddress, 
			taker: NULL_ADDRESS,
	           	feeRecipient: NULL_ADDRESS,
	            	makerTokenAddress: ZRX_ADDRESS,
	            	takerTokenAddress: WETH_ADDRESS,
	            	exchangeContractAddress: EXCHANGE_ADDRESS,
	            	salt: ZeroEx.generatePseudoRandomSalt(),
	            	makerFee: new BigNumber(0),
	            	takerFee: new BigNumber(0),
	            	makerTokenAmount: ZeroEx.toBaseUnitAmount(new BigNumber(0.2), DECIMALS),   // Base 18 decimals
	            	takerTokenAmount: ZeroEx.toBaseUnitAmount(new BigNumber(0.3), DECIMALS),   // Base 18 decimals
	            	expirationUnixTimestampSec: new BigNumber(Date.now() + 3600000),          // Valid up to an hour
	        };

	// Create orderHash
	const orderHash = ZeroEx.getOrderHashHex(order);

	// Signing orderHash -> ecSignature
	const ecSignature = await zeroEx.signOrderHashAsync(orderHash, makerAddress);

	//Appending signature to order
	const signedOrder = { 
			      ...order, 
	        	      ecSignature, 
	      		     };

	//Verify if order is fillable
	await zeroEx.exchange.validateOrderFillableOrThrowAsync(signedOrder);

	//Try to fill order
	const shouldThrowOnInsufficientBalanceOrAllowance = true;
	const fillTakerTokenAmount = ZeroEx.toBaseUnitAmount(new BigNumber(0.1), DECIMALS);

	//Try filling order
	const txHash = await zeroEx.exchange.fillOrderAsync(signedOrder, fillTakerTokenAmount, 
		 					    shouldThrowOnInsufficientBalanceOrAllowance, takerAddress,
    							    );
	//Transaction Receipt
	const txReceipt = await zeroEx.awaitTransactionMinedAsync(txHash)
	console.log(txReceipt.logs);

})().catch(console.log);