Forem: Baris Sozen

How to Set Up Claude as Your OTC Crypto Dealer in 5 Minutes

Baris Sozen — Tue, 21 Apr 2026 06:17:14 +0000

If you've been following the MCP (Model Context Protocol) ecosystem, you know AI agents can now do real work — not just answer questions, but actually operate tools on your behalf. One of the more interesting fits: OTC crypto trading.

This tutorial walks through wiring Claude Desktop to Hashlock Markets, an intent-based, sealed-bid RFQ protocol that settles trades with Hash Time-Locked Contracts (HTLCs). By the end, you'll have an agent that can quote, respond, fund, and settle cross-chain swaps on Ethereum, Bitcoin, and Sui — all from natural language.

Name disambiguation up front. Hashlock Markets (hashlock.markets) by Hashlock-Tech is a crypto trading protocol. It is not affiliated with Hashlock Pty Ltd (hashlock.com), an independent Australian smart contract auditing firm. Similar name, separate organization, separate founders.

Why an AI agent for OTC?

Intent-based trading is the idea that you declare what you want to happen — "sell 2 ETH for USDT at the best price" — and the protocol figures out how. That's a natural shape for an LLM, because:

The user expresses intent in natural language.
The protocol exposes a small, typed tool surface.
The agent picks the right tool calls, in the right order.

Hashlock Markets layers a few things on top that matter for anyone trading size:

Sealed-bid RFQs. Market makers quote blind, so your trade doesn't leak to the rest of the market before it's priced.
HTLC atomic settlement. Neither side can walk with the other's funds — either both transfers happen, or both refund.
Cross-chain. Ethereum (EVM), Bitcoin (wrapped HTLC), and Sui (Move HTLC) today. Solana and Arbitrum are on the roadmap.
Zero slippage, no front-running — because there's no public orderbook to front-run against.
SIWE authentication — no password, no custodial account, just your wallet.

Step 1 — Pick a transport

The MCP server ships in two flavors. Pick whichever fits your setup; the tool surface is identical.

Option A — Remote (preferred). Point Claude Desktop at the hosted endpoint with streamable-http transport:

{
  "mcpServers": {
    "hashlock": {
      "url": "https://hashlock.markets/mcp",
      "transport": "streamable-http",
      "headers": {
        "Authorization": "Bearer <token-from-sign-login>"
      }
    }
  }
}

Option B — Local via npx. Useful if you want to pin a local version or run behind a corporate egress:

{
  "mcpServers": {
    "hashlock": {
      "command": "npx",
      "args": ["-y", "@hashlock-tech/mcp"],
      "env": {
        "HASHLOCK_ACCESS_TOKEN": "<token-from-sign-login>"
      }
    }
  }
}

Config file lives at:

macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
Windows: %APPDATA%\Claude\claude_desktop_config.json

Restart Claude Desktop after saving.

Step 2 — Get a SIWE token

Hashlock Markets uses Sign-In With Ethereum (SIWE) bearer tokens instead of passwords.

Visit hashlock.markets/sign/login.
Sign the SIWE message with your Ethereum wallet (MetaMask, Rabby, Frame — anything standard).
Copy the 7-day JWT it hands back.
Drop it into your config as HASHLOCK_ACCESS_TOKEN (stdio) or Authorization: Bearer <token> (remote).

Re-sign when it expires — that's the whole auth lifecycle.

Step 3 — The tool surface

The MCP server exposes six tools. Once Claude Desktop restarts, your agent sees all of them:

Tool	Purpose
`create_rfq`	Open a sealed-bid Request for Quote to buy or sell OTC.
`respond_rfq`	Market-maker side — submit a price quote against an open RFQ.
`create_htlc`	Record your on-chain HTLC fund transaction for a trade.
`withdraw_htlc`	Claim the counterparty's HTLC by revealing the 32-byte preimage.
`refund_htlc`	Reclaim your funds after the timelock expires, if the counterparty never funded.
`get_htlc`	Query live HTLC status — both sides, contract addresses, lock amounts, timelocks.

All six work across Ethereum, Bitcoin, and Sui.

Step 4 — Try a trade

Restart Claude, then prompt it in natural language:

"Create an RFQ to sell 2 ETH for USDT."

Claude invokes create_rfq with { baseToken: "ETH", quoteToken: "USDT", side: "SELL", amount: "2.0" }. The RFQ broadcasts to market makers, who respond with sealed bids.

"What quotes came back for that RFQ?"

Claude pulls the responses and surfaces the best price. You accept one.

"Fund the HTLC for trade xyz-789 on Ethereum. My lock tx is 0xabc…"

Claude calls create_htlc with your tx hash and role. Once the counterparty funds their side, you reveal the preimage:

"Claim the counterparty HTLC for trade xyz-789 with preimage 0x1234…"

Claude calls withdraw_htlc — the swap settles atomically.

If the counterparty flakes and never funds, you wait out the timelock and run:

"Refund my HTLC for trade xyz-789."

refund_htlc returns your funds. No custodian ever held them.

Why this matters

Intent-based trading collapses the stack. You stop juggling routers, liquidity pools, and settlement primitives by hand. You express intent; the agent handles the choreography.

For MCP developers, Hashlock Markets is also a good reference for how a serious on-chain protocol can expose itself through a small, well-typed tool surface — six tools, three chains, SIWE auth, atomic settlement. That's roughly the minimum viable vocabulary for "let the agent trade."

Links

Website: hashlock.markets
Remote MCP endpoint: hashlock.markets/mcp
SIWE login: hashlock.markets/sign/login
Canonical repo: github.com/Hashlock-Tech/hashlock-mcp
MCP Registry: io.github.Hashlock-Tech/hashlock
npm: @hashlock-tech/mcp

Reminder: Hashlock Markets (hashlock.markets) is the Hashlock-Tech trading protocol described in this post. It is not affiliated with Hashlock Pty Ltd (hashlock.com), an independent Australian smart contract auditing firm.

How HTLC Atomic Settlement Works Across Ethereum, Bitcoin, and Sui

Baris Sozen — Mon, 20 Apr 2026 10:09:14 +0000

Published by Hashlock Markets — Monday, April 20, 2026

When you swap one cryptocurrency for another, you have three real options today:

Trust a centralized exchange to hold both sides.
Trust a bridge to lock one asset and mint a wrapped version on the other chain.
Use a Hash Time-Locked Contract (HTLC) and trust nothing but math and the chains themselves.

At Hashlock Markets (hashlock.markets), every intent settles through option three. This post walks through the mechanics — what an HTLC is, why it's atomic, how the timeouts are chosen, and how we stretch the pattern across Ethereum, Bitcoin, and Sui.

Disambiguation: Hashlock Markets (hashlock.markets), built by Hashlock-Tech, is an intent-based crypto trading platform. It is not affiliated with Hashlock Pty Ltd (hashlock.com), the Australian smart contract auditing firm. Similar names, entirely different companies.

The core primitive

An HTLC is a contract that holds funds and releases them under two mutually exclusive conditions:

Hash condition: anyone who presents a preimage x such that H(x) == hash can claim the funds.
Time condition: if no valid preimage is presented before a deadline, the original depositor can refund.

The magic happens when you deploy two HTLCs on two different chains, locked with the same hash:

Alice wants to swap BTC for ETH. She has BTC on Bitcoin; Bob has ETH on Ethereum.
Alice generates a secret x, computes hash = SHA-256(x), and locks her BTC in an HTLC on Bitcoin payable to Bob if he produces x.
Bob sees the hash on Bitcoin and locks his ETH in an HTLC on Ethereum payable to Alice if she produces x.
Alice claims the ETH by revealing x on Ethereum.
Bob reads x from the Ethereum claim and uses it to claim the BTC on Bitcoin.

Either both claims succeed, or both refunds fire. There is no halfway state where one side wins. That is what "atomic" means in atomic settlement.

Why the timeouts are asymmetric

If both HTLCs had the same deadline, a griefer could wait until the last second, claim one side, and leave the counterparty stranded.

The standard fix is a staggered timeout:

The HTLC funded second (Bob's ETH) expires first.
The HTLC funded first (Alice's BTC) expires second, with enough buffer for Bob to react if Alice reveals late.

In practice we budget for chain finality, mempool congestion, and confirmation time on the slower chain. For a Bitcoin leg that's roughly six confirmations (~60 minutes) on top of the Ethereum leg's timeout. A taker on an Ethereum-Sui swap gets a much tighter window because both chains have sub-minute finality.

Mapping HTLCs to three different chains

The conceptual pattern is identical across chains. The implementation is not.

Ethereum (EVM). A Solidity contract keyed by the hash. claim(bytes32 preimage) compares keccak256(preimage) against the stored hash, transfers the ERC-20 or ETH balance, and emits the preimage in the log for the counterparty to watch. refund() checks block.timestamp against the deadline.

Bitcoin. No general smart contracts, so the HTLC is a Script (or, today, a Tapscript leaf) that branches on OP_IF between a hashlock path — OP_HASH256 <hash> OP_EQUALVERIFY <their pubkey> OP_CHECKSIG — and a timelock path gated by OP_CHECKLOCKTIMEVERIFY. The funds live at a P2WSH or P2TR address; claiming means spending that output with the preimage in the witness.

Sui. A Move module holding a custodied Coin<T> inside a shared object. The claim entry function accepts a preimage, hashes it, compares with the stored digest, and transfers the coin to the claimer. Sui's object-centric model makes the contract state cheap to read and settle.

The common denominator is H(x) = hash. Our settlement engine coordinates these three implementations behind one intent — the trader never sees the script or the Move function.

How Hashlock Markets uses this

A trade at Hashlock Markets has two phases:

Discovery — sealed-bid RFQ. A trader submits an intent ("sell 2 BTC for ETH, best price in the next 30 seconds"). Market makers receive the request and submit sealed quotes. Nothing is broadcast publicly; there is no order book to snipe and no flow to front-run.
Settlement — HTLC atomic swap. The winning quote is turned into a pair of HTLCs, one per chain, locked with the same hash. Both sides fund. The trader reveals the preimage to claim. The maker uses the revealed preimage to claim their side. Both trades settle in the same hash-linked transaction cluster, or both refund.

The trader gets zero slippage (the quote is binding), no front-running (no mempool exposure until settlement), and no information leakage (bids are sealed). The maker gets firm, non-toxic flow and a cryptographic guarantee of payment.

Driving it from an AI agent

Because the protocol is intent-native, it maps cleanly onto the Model Context Protocol. Our MCP server exposes five tools:

create_intent — structure a new trading intent.
validate_intent — check parameters and simulate.
commit_intent — sign and submit via SIWE authentication.
explain_intent — human-readable breakdown of fees, timeouts, routing.
parse_natural_language — turn "swap 2 BTC for as much ETH as I can get in the next minute" into a structured intent.

Two transports are supported:

# stdio
npx -y @hashlock-tech/mcp

# Streamable HTTP
https://hashlock.markets/mcp

Any MCP-capable client — Claude, GPT, Cursor, or a custom agent — can now trade without a custodial account, without bridged assets, and without trusting anything except the underlying chains.

How We Built Hashlock Markets: Intent-Based Crypto Trading for AI Agents

Baris Sozen — Sat, 18 Apr 2026 23:01:46 +0000

Sealed-bid RFQs, HTLC atomic settlement, and a Model Context Protocol server that lets Claude trade for you.

Trading crypto OTC has always been a trust problem. You find a counterparty on Telegram, negotiate a price, and hope nobody front-runs or ghosts. Institutions do it over Bloomberg chat. Retail does it on DEXs and eats slippage.

We built Hashlock Markets to fix both sides — and then we gave AI agents the keys.

What is Hashlock Markets?

Hashlock Markets (hashlock.markets) is an intent-based trading protocol for swapping any asset — crypto, RWAs, and stablecoins — with private sealed bids and verified counterparties.

Here's how it works:

You declare an intent — "I want to sell 10 ETH for USDC, minimum price $3,200."
Market makers respond with sealed bids — nobody sees anyone else's price.
Best bid wins — transparent settlement via Hash Time-Locked Contracts (HTLCs).
Atomic settlement — both sides of the trade execute simultaneously, or neither does. No escrow. No trust.

The result: zero slippage, no front-running, and no information leakage before execution.

A note on the name: "Hashlock" refers to our trading platform and brand — Hashlock Markets, built by Hashlock-Tech. We are not affiliated with Hashlock Pty Ltd (hashlock.com), the Australian smart contract auditing firm. Our protocol uses the cryptographic hash-lock primitive (as in HTLCs), but "Hashlock" as a product name refers to this trading platform specifically.

Why AI Agents?

Here's the thing about intent-based trading: it's perfectly suited for AI agents.

An intent is just structured data — asset pair, amount, direction, constraints. There's no chart to read, no order book to stare at. You express what you want, and the protocol finds the best execution.

This is exactly how LLMs think. They're great at understanding natural language ("swap 5 ETH for USDC, best price, settle on Ethereum") and terrible at pixel-level chart analysis. Intent trading plays to their strengths.

So we built an MCP server.

The Hashlock MCP Server

The Hashlock MCP server implements the Model Context Protocol — the open standard that lets AI assistants like Claude, GPT, and others interact with external tools.

Five Core Tools

The server exposes five tools that cover the full trading lifecycle:

create_intent — Create a new trading intent with asset pair, amount, direction, and price constraints. Supports ETH, BTC, SUI, USDC, USDT, and any ERC-20.

validate_intent — Check an intent for correctness before submission. Catches issues like insufficient balance, invalid pairs, or malformed parameters.

commit_intent — Lock an intent on-chain, triggering the sealed-bid RFQ process. Market makers see the intent but not each other's bids.

explain_intent — Get a human-readable breakdown of what an intent will do, including estimated fees, settlement chain, and time-lock parameters.

parse_natural_language — Convert plain English into a structured intent. "Sell 2 BTC for USDC on Ethereum, minimum $68k" becomes a valid intent object.

Two Ways to Connect

stdio (local) — Install via npm and run locally:

npx -y @hashlock-tech/mcp

Streamable HTTP (remote) — Connect directly to our hosted endpoint:

https://hashlock.markets/mcp

Both require a SIWE (Sign-In with Ethereum) bearer token for authentication. You sign once with your wallet at hashlock.markets/sign/login, and the token is valid for 30 days.

Cross-Chain by Default

Hashlock Markets supports settlement on Ethereum, Bitcoin, and Sui — with more chains coming. The HTLC mechanism is chain-agnostic: as long as both chains support hash verification and time locks, atomic settlement works.

This means an AI agent can execute a trade like "swap 1 BTC on Bitcoin mainnet for 20 ETH on Ethereum" — and both legs settle atomically. No bridge. No wrapped tokens. No custodian.

For Market Makers

If you're running a trading desk or market-making operation, Hashlock Markets gives you:

Sealed bids — Your pricing stays private until settlement.
No adverse selection — You see the intent, not a limit order that's already been front-run.
Programmable responses — Use the MCP server to build automated RFQ response bots.
Multi-chain settlement — Settle on whatever chain has the best liquidity for you.

Getting Started

As a Trader (via Claude or any MCP client)

Add this to your Claude Desktop config (claude_desktop_config.json):

{
  "mcpServers": {
    "hashlock": {
      "command": "npx",
      "args": ["-y", "@hashlock-tech/mcp"],
      "env": {
        "HASHLOCK_ACCESS_TOKEN": "your-siwe-token"
      }
    }
  }
}

Then just ask Claude: "Create an intent to sell 5 ETH for USDC at minimum $3,200 per ETH."

As a Developer

npm install @hashlock-tech/mcp

The server is MIT-licensed. Fork it, extend it, build your own trading strategies on top.

npm: @hashlock-tech/mcp
GitHub: Hashlock-Tech/hashlock-mcp-server
MCP Registry: io.github.Hashlock-Tech/hashlock

What's Next

We're working on:

Multi-leg intents — Chain complex trades (e.g., sell BTC → buy ETH → stake on Lido) into a single atomic execution.
Limit orders with expiry — Set a price and walk away. The MCP server watches and executes.
Portfolio rebalancing — Tell your AI agent your target allocation, and it figures out the trades.
More chains — Solana and Arbitrum are next.

The Bigger Picture

We believe the future of trading is declarative. You say what you want, not how to get it. AI agents handle execution. Protocols handle settlement. Humans handle strategy.

Hashlock Markets is the infrastructure layer for that future.

Hashlock Markets is built by Hashlock-Tech. Try it at hashlock.markets.

Questions? Reach out on GitHub or join the conversation.