BFX Test Assignment

Set up environment

npm install

To start the server

sh server.sh

To start the client

sh client.sh eth buy 100 5

The first arguement is token. eg. 'eth' or 'bnb' The second arguement is side. eg. 'buy' or 'sell' The third arguement is price. The last arguement is quantity.

Discribe the codes at client side

Create Link and Establish a P2P connection

const link = new Link({
    grape: 'http://127.0.0.1:30001'
})
link.start()

const peer = new PeerRPCClient(link, {})
peer.init()

Get random wallet address and random balance, and Save the balance to the node.

If we get the wallet address from ui in the real world, there is no need to save it to node.

const walletAddress = await generateWalletAddress()
const balance = {
    address: walletAddress,
    eth: randomizer(1, 10),
    bnb: randomizer(1, 100),
    usdc: randomizer(50000, 100000),
}
const tokens = ['eth', 'bnb', 'usdc']       // only trade with eth and bnb right now
const determination = ['sell', 'buy']

link.put({ v: JSON.stringify(balance) }, (err, hash) => {
    console.log(`Balance saved to the DHT`, err, hash);
    if (hash == 'No nodes to query') {
        process.exit(-1);
    }
    balanceHash = hash
    peer.map('rpc_test', { msg: 'hello', hash: balanceHash }, { timeout: 10000 }, (err, data) => {
        if (err) {
            console.error(err)
            process.exit(-1)
        }
        console.log(data)
    })
})

Make an order and Add the order to orderbook.

const order = {
    clientId: walletAddress,
    token: TOKEN,
    side: SIDE,
    price: PRICE,
    quantity: QUANTITY,
}

peer.request('createOrder', order, { timeout: 10000 }, (err, data) => {
    if (err) {
        console.error(err)
        process.exit(-1)
    }
    console.log(data)
})

Request to get the OrderBook instance.

peer.request('getOrderInstance', { address: walletAddress }, { timeout: 10000 }, (err, data) => {
    if (err) {
        console.error(err)
        process.exit(-1)
    }
    console.log("Here is the OrderInstance", data)
})

Discribe the codes at server side

Create an Link and establish a PearRPCServer.

const link = new Link({
    grape: 'http://127.0.0.1:30001'
})
link.start()

const peer = new PeerRPCServer(link, {
    timeout: 300000
})
peer.init()

Set the current Ether value and BNB value.

The values can get from Market information in the real world.

const currentEtherToUSDC = 2000
const currentBNBToUSDC = 300

Announce the service.

rpc_test : To say hello and save the client wallet address to node.

createOrder : To create an order and match the orders

getOrderInstance : To return the orderbook instance for specific client.

setInterval(function () {
    link.announce('rpc_test', service.port, {})
    link.announce('createOrder', service.port, {})
    link.announce('getOrderInstance', service.port, {})
}, 1000)

rpc_test

Get the balance from given hash.

// First say hello and register the client the wallet address and its balance
if (key === 'rpc_test') {

    // acquire the lock before processing the request
    const release = await mutex.acquire()

    const { hash } = payload
    if (hash) {
        link.get(hash, (err, res) => {
            // console.log('data requested to the DHT', err, res)

            const balance = JSON.parse(res.v)
            clients[balance.address] = { hash, ...balance }

            // console.log('here is clients :', clients)
            // clients.push({ hash: balance })
        })
    }

    // release the lock once the critical section is complete
    release()

    handler.reply(null, { msg: 'world' })
}

createOrder

First check if the client can perform the order.

const order = payload
const clientBalance = clients[order.clientId]
console.log('Client Balance', clientBalance)

// Check if the client can buy or sell
if (order.side === 'buy') {
    // check if the client can buy
    if (order.token === 'eth' && clientBalance.usdc >= order.price * order.quantity) {
        handler.reply(null, { msg: 'Creating Order Failed, Insufficient Ether' })
        return
    }
    if (order.token === 'bnb' && clientBalance.usdc >= order.price * order.quantity) {
        handler.reply(null, { msg: 'Creating Order Failed, Insufficient BNB' })
        return
    }
} else {
    // check if the client can sell
    if (order.token === 'eth' && clientBalance.eth <= order.quantity) {
        handler.reply(null, { msg: 'Creating Order Failed, Insufficient USDC' })
        return
    }
    if (order.token === 'bnb' && clientBalance.bnb <= order.quantity) {
        handler.reply(null, { msg: 'Creating Order Failed, Insufficient USDC' })
        return
    }
}