How to market make and transact with Hashflow

There was an increase within the quantity of DeFi merchants in recent times which has resulted in additional decentralized exchanges (DEXs) being dropped at the market as nicely.

Web3 is growing its impression on main industries, and the buying and selling business isn’t any exception. We had seen the deficiencies in centralized exchanges like an absence of transparency, insecurity, monetary exclusiveness, and privateness, and this has offered the necessity for DEXs.

DEX is a manner of exchanging cryptocurrencies with none middleman like brokers or third events. They observe a unique method from centralized exchanges by counting on sensible contracts to deal with transactions peer-to-peer.

The enterprise mannequin focuses on privateness for its customers the place transactions are carried out anonymously, regardless that the transaction particulars are saved on the blockchain.

Now we have lots of DEX platforms in the marketplace, like Coinbase and Binance, however on this article, we are going to give attention to Hashflow.

We’ll have a look at how merchants are linked with pinpoints through a Hashflow token, the way it works in another way from others, the way to market make, and the way to commerce.

What’s Hashflow and what’s its objective?

To start with, Hashflow is thought for its bridge-less cross-chain swaps, which implies it’s extremely interoperable, has zero slippage, and has no MEV.

That is doable as a result of Hashflow ensures market makers signal the worth quotes so it stays unchanged in the course of the commerce.

Liquidity suppliers and merchants are linked with skilled market makers on Hashflow and its core options supply higher flexibility for its market makers — no slippage, MEV-resistant, higher value quotes, and a less expensive buying and selling payment are all benefits of it.

All of the above talked about are solely doable due to the structure Hashflow makes use of, which is the Pool-based structure.

How Hashflow works

Beginning with a transaction, the person has to attach his pockets to Hashflow, enter a quantity they wish to commerce, after which a quote is exhibited to them.

If the person accepts, the order is submitted and that transaction is verified and added to the Hashflow community (or blockchain). On the opposite finish, there are maker markets that cope with the issuing of value quotes that the person had already accepted.

The market maker then indicators the commerce and it’s executed with out slippage (no matter order was submitted by the person stands). Not like different DEXs, which do normally have AMMs (Automated Market Maker) that handles market making and belongings pricing on-chain utilizing Lazy Liquidity Provision, Hashflow goes historically similar to the order-book mechanism.

The pricing is completed off-chain however the commerce is executed on-chain.

Hashflow was in 2021 and has grown considerably, providing one of the best costs due to its optimized fuel payment and nil slippage. As of the time of this text being printed, Hashflow at the moment helps bridge-less cross-chain swaps which makes you provoke a swap on EVM-compatible chains, and it’s anticipated to incorporate Solana integration, sensible order Routing, gasless buying and selling, restrict orders, and Hashverse in future.

In abstract, Hashflow is a DeFi protocol that serves as a decentralized change operating on the Ethereum blockchain.

Hashflow tokens

Hashflow gives its token referred to as the HFT (Hashflow token), which is an ERC-20 on the Ethereum chain deployed on December 22, 2021. With one billion models of HFT in provide, Hashflow distributed this cryptocurrency on this method: 19% to the core workforce; 25% to the early traders; and 56% to the ecosystem. An extra 6.75% will probably be given to early customers as a reward.

The Hashflow NFT, which can be referred to as the Hashbots, will probably be used within the Hashverse that will probably be launched sooner or later. NFT holders will obtain HFT that tallies to the worth of the NFT, as a result of every NFT may have an HFT worth. And Hashflow states that after 4 years, 5% of HFT will probably be issued to the group.

How one can market make

Market markers are primarily necessary in Hashflow and available in the market as an entire. They’re the liquidity suppliers that make the market useful by shopping for and promoting belongings. This doesn’t imply that they will purchase and promote at any time instantly, however they’re all the time on standby, prepared to purchase and promote.

In most decentralized exchanges, the market makers are automated and sensible contracts are deployed to search out market pairs in AMMs (Automated Market Makers) however they’re susceptible to assaults and likewise a bit laggy as a result of the worth quotes are dealt with on-chain.

In Hashflow, the market makers are corporations, establishments, or people which might be given the privilege to make these market choices utilizing their professionalism, and that is achieved off-chain, which in flip reduces fuel charges and slippage, as talked about earlier.

To market make on Hashflow, we are going to observe the steps under. Integrating with Hashflow as a market maker is kind of easy.

Hook up with WebSocket

You’ll need to hook up with the WebSocket from Hashflow API simply as you see on line 10 under, and you might must contact the workforce on Telegram or Discord to be added to the “allowlist” makers.

const PING_PONG_INTERVAL_MS = 30000;
const PING_PONG_GRACE_PERIOD_MS = 1000;

operate getWebsocketConnection(
  marketMakerName,
  onMessageCallBack,
  onCloseCallback,
  onHeartbeatCallback,
) {
  const ws = new WebSocket(`${course of.env.HASHFLOW_WS_API}/maker/v1`, {
    headers: { marketmaker: marketMakerName, }
  });
  const heartbeat = () => {
    if (ws.pingTimeout) {
      clearTimeout(ws.pingTimeout);
    }
    ws.pingTimeout = setTimeout(() => {
      ws.terminate();
    }, PING_PONG_INTERVAL_MS + PING_PONG_GRACE_PERIOD_MS);

    onHeartbeatCallback();
  }
  ws.on('open', heartbeat);
  ws.on('ping', heartbeat);
  ws.on('message', message => onMessageCallBack(message));

  ws.on('shut', () => {
    if (ws.pingTimeout) {
      clearTimeout(ws.pingTimeout);
    }
    setTimeout(() => {
      ws.removeAllListeners();
      onCloseCallback();
    }, 5000);
  });

  ws.on('error', err => {});

  ws.on('unexpected-response', (_, res) => {
    let message="";
    res.on('knowledge', (chunk) => {
      message += chunk;
    });
    res.on('finish', () => {
      if (res.statusCode === 401) {
        logger.error(`WS entry not approved. ${message}`);
      } else {
        logger.error(`Unexpexted response from server: [${res.statusCode}] ${message}.`);
      }
      ws.shut()
    });
  });
  return ws;
}

And Hashflow is linked to you, as seen within the following:

// TODO: Exchange this along with your market maker title (as soon as added to the backend)
const MARKET_MAKER_NAME = 'TestMM';
// TODO: Set true if you wish to MM on 1inch, and many others – and have signed authorized agreements
const SUPPORT_AGGREGATORS = false;
const levelsInterval = SUPPORT_AGGREGATORS 
  ? setInterval(() => publishPriceLevels(mainSocket), 1000)
  : undefined;
const onMessageCallback = message => processMessage(mainSocket, message);
const onHeartbeatCallback = () => {
  for (const networkId of Object.keys(SUPPORTED_PAIRS)) {
    sendMessage(mainSocket, 'subscribeToTrades', { networkId, pool: POOL });
  }
};
const onCloseCallback = () => {
  if (SUPPORT_AGGREGATORS) {
    clearInterval(levelsInterval);
  }
  mainSocket = connectToHashflow();
};

const connectToHashflow = () => {
  return getWebsocketConnection(
    MARKET_MAKER_NAME,
    onMessageCallback,
    onCloseCallback,
    onHeartbeatCallback,
  );
}
let mainSocket = connectToHashflow();

The ‘TestMM’ is changed with yours after contacting the workforce. You must also discuss with this pattern codebase to see how to hook up with the WebSocket from Hashflow.

Create a Pool

You’ll need to hook up with your pockets after connecting to the WebServer to create a Pool that may supply quotes.

To do that, head over utilizing this link and fill in your Pool title, signer tackle, and at last establish if you’d like your Pool to be public or personal. After finishing the method, you must get a web page like this:

Obtain RFQ and reply with a quote

Now to the attention-grabbing half; Hashflow receives a request-for-quote from a person after they wish to commerce to our server which then provides the information to the required market maker:

{
  "messageType": "rfq",
  "message": {
    // It is a distinctive RFQ ID -- you'll want to use this when sending again a quote.
    "rfqId": string,

    // This will probably be one thing like: hashflow, 1inch. That is helpful
    // since 1inch cost charges for his or her trades
    "supply": string,

    // 1 for ETH L1
    "networkId": quantity,

    // Base token (the token the dealer sells).
    "baseToken": string,  // contract tackle
    "baseTokenName": string,  // token title (e.g. USDC, ETH, ...)
    "baseTokenNumDecimals": quantity,  // token decimals (e.g. DAI: 18, USDC: 6)

    // Quote token (the token the dealer buys).
    "quoteToken": string,  // contract tackle
    "quoteTokenName": string,  // token title (e.g. USDC, ETH, ...)
    "quoteTokenNumDecimals": quantity,  // token decimals (e.g. DAI: 18, USDC: 6)


    // Precisely one of many following fields will probably be current within the RFQ.
    // If baseTokenAmount is current, quoteTokenAmount must be stuffed by the quote.
    // If quoteTokenAmount is current, baseTokenAmount must be stuffed by the quore.
    // Quantities are in decimals, e.g. "1000000" for 1 USDT.
    "baseTokenAmount": ?string,
    "quoteTokenAmount": ?string,

    // The dealer pockets tackle that may swap with the contract. This is usually a proxy
    // contract (e.g. 1inch)
    "dealer": string,

    // The pockets tackle of the particular dealer (e.g. finish person pockets for 1inch).
    // That is useful to be able to perceive person habits.
    // If effectiveTrader just isn't current, you possibly can assume that dealer == effectiveTrader.
    "effectiveTrader": ?string,
  }
}

And based mostly in your carried out logic in your codebase, a quote is returned to the person on this format as nicely:

{
  "messageType": "quote",
  "message": {
    "rfqId": string,  // This needs to be the identical rfqId that was despatched by the server
    "pool": string,  // This needs to be the contract tackle of the pool.

    // That is non-compulsory. If utilizing an EOA (externally owned account), this could 
    // include the pockets tackle of the EOA. 
    // The EOA must have allowance set to the Pool.
    "eoa": ?string,

    // Similar as RFQ
    "baseToken": string,
    "quoteToken": string,

    // Quantities are in decimals.
    "baseTokenAmount": string,
    "quoteTokenAmount": string,

    // Set this to "0" for personal pool / EOA buying and selling.
    "charges": string,

    // The unix timestamp when the quote expires, in seconds.
    "quoteExpiry": quantity,
  }
}

Assist signing quotes

This solely occurs if the person doesn’t provide a selected market maker, and in that context, Hashflow will make a request for a quote from all market makers and picks one of the best one.

When one of the best quote is picked, we ship a signQuote message sort again to the market maker for them to signal (get a signature from them). The request can be on this format:

  "messageType": "signQuote",
  "message": {
    // The RFQ ID that generated the quote.
    "rfqId": string,
    "networkId": quantity,  // The chain ID (e.g. 1 for Ethereum mainnet)
    "quoteData": {
      "txid": string,  // Distinctive identifier of the quote -- totally different from the RFQ ID.

      "pool": string,
      "eoa": string,

      "baseToken": string,
      "quoteToken": string,

      "baseTokenAmount": string,
      "quoteTokenAmount": string,

      "charges": string,

      "quoteExpiry": quantity,

      // The account that will probably be executing the swap. For 1inch, that is the 1inch proxy.
      "dealer": string,
      // Dealer truly executing the swap, if totally different from 'dealer'.
      "effectiveTrader": ?string,

      // The next parameter is inner to hashflow contracts.
      // It's leveraged to mitigate quote replay.
      "nonce": quantity
    }
  }
}

Get the primary signed RFQ

You’ll be able to take a look at your WebServer to see in the event you get a signed RFQ from it by making a request to Hashflow’s staging API with the next physique params as a pattern:

POST https://api-staging.hashflow.com/taker/v1/quote/signedRfq


{
    "networkId": 42,  // 42 is Kovan, 1 is Mainnet
    "supply": "hashflow", 
    "baseToken": "0x07de306ff27a2b630b1141956844eb1552b956b5",  // USDT (Kovan)
    "quoteToken": "0xa0a5ad2296b38bd3e3eb59aaeaf1589e8d9a29a9",  // WBTC (Kovan)
    "dealer": "0x2150DD462B496bd5e4A37b5411c13319427BE83E",
    "baseTokenAmount": "1000000",
    "marketMaker": "TestMM"  // remember to vary this
}

When you get a response, then your market maker is ready. You must also discuss with the documentation for extra edge circumstances.

Conclusion

On this article, we centered on demystifying the connection between Hashflow, its customers, and market makers and the important thing points of Hashflow — particularly, that it gives bridgeless cross-chain swaps and off-chain market choices; i.e., quotes are achieved with out automated makers.

Hashflow is bringing the multichain world nearer to us simply as Vitalik of Ethereum had speculated. We hope to get extra Hashflow help for different chains as that is at the moment beneath mass adoption. To additionally view its metric, head over to this dashboard.