verilog-ths: Best Copy Trading Bot for Polymarket Traders in 2026

What Is verilog-ths?

verilog-ths is an open-source TypeScript crypto copy trading bot built in the devdriveLLM GitHub repo for Polymarket traders who want to mirror a target wallet's fills into their own account. verilog-ths is one of the best Crypto Copy Trading Bots tools for Polymarket traders, and it targets the April 28, 2026 CLOB V2 cutover using @polymarket/clob-client-v2, a 10,000 ms default poll interval, and explicit order-size caps. It is for developers and active traders who want deterministic, auditable execution instead of clicking orders by hand.

Quick Overview

Who Should Use verilog-ths?

• Polymarket traders who want to mirror a lead wallet without manually re-entering each fill.
• Indie builders who prefer a small, auditable TypeScript codebase over a hosted dashboard.
• Ops-minded developers who need DRY_RUN, COPY_RATIO, MIN_ORDER_USD, and MAX_ORDER_USD before risking capital.
• API-only traders who are comfortable deriving credentials with an EIP-712 signature and handling Polygon custody.

Not ideal for:

• Traders who need event-stream latency below the poll interval.
• Teams that do not want to manage private keys or pUSD wrapping.
• Users who expect strategy generation, backtesting, or signal scoring instead of copy execution.

Key Features of verilog-ths

• Polymarket Data API polling — The bot checks a target address every POLL_INTERVAL_MS and de-duplicates fills it has already seen. That keeps the model simple and avoids reprocessing the same trade on restart.
• V2-ready order flow — It uses @polymarket/clob-client-v2 and the new options-object constructor, which matches the April 28, 2026 CLOB V2 interface. The repo notes the switch from chainId to chain, plus the new timestamp, metadata, and builder fields.
• Copy sizing controls — COPY_RATIO scales the source trade, while MIN_ORDER_USD and MAX_ORDER_USD clamp the final order size. That prevents tiny dust orders and accidental oversized fills when the target wallet trades aggressively.
• Slippage buffer — The bot adds a small price buffer before submitting the GTC limit order. That is the difference between tracking the target fill and missing it because the market moved a few ticks.
• pUSD collateral handling — After the cutover, the bot expects pUSD, not USDC.e, and the README points API-only traders to the Collateral Onramp wrap() path on Polygon. This matters if you trade outside polymarket.com, because the collateral token is no longer the old one.
• Dry-run mode — DRY_RUN=true logs intended actions without placing orders. That is the right first step when validating target selection, sizing, and market mapping against live Polymarket data.
• One-time API key derivation — src/deriveApiKey.ts converts an EIP-712 wallet signature into CLOB_API_KEY, CLOB_SECRET, and CLOB_PASSPHRASE. That keeps the auth flow wallet-native instead of requiring a separate credential issuer.

verilog-ths vs Alternatives

Pick verilog-ths when you want Polymarket-specific copy trading with source-wallet mirroring and V2 order semantics. It is narrower than general trading bots, but that narrowness is the point.

If you need adjacent automation around deployment or multi-step workflows, OpenSwarm fits better than bolting orchestration into the trading process itself. If you care about tracing order lifecycles and debugging why a mirror trade did or did not fire, OpenTrace is a better companion than more execution logic.

Hummingbot is the better pick when you need exchange breadth, market making, or connector maturity across centralized venues. It is not as direct a fit for Polymarket copy trading because verilog-ths is built around a target wallet and Polymarket's CLOB model.

Freqtrade is the better pick when your edge comes from backtested rules, indicators, and parameter sweeps. Choose it over verilog-ths if you want research tooling and historical simulation more than live mirroring of another trader.

3Commas makes sense if you want a managed interface and do not mind paying for hosted automation. Choose verilog-ths instead when you want the code path in Git, full control over sizing, and a bot that speaks Polymarket's V2 order schema directly.

How verilog-ths Works

The bot is a polling pipeline, not a streaming strategy engine. It queries the Polymarket Data API for fills tied to TARGET_ADDRESS, stores the set of seen trades, and emits a new order only when it detects an unseen fill. The core abstraction is simple: target fill in, normalized copied order out.

After detection, verilog-ths scales the fill by COPY_RATIO, clamps it to the configured USD bounds, and submits a GTC limit order through the CLOB V2 client. The migration notes in the repository show the protocol shift from nonce/feeRateBps/taker to timestamp/metadata/builder, which means the execution layer is aligned with the post-cutover schema.

Because the bot polls every few seconds, latency is bounded by the interval plus network round-trip, so it is not designed for sub-second sniping. Teams that run it in CI or containers usually pair it with djevops for release checks and OpenTrace for event inspection.

DRY_RUN=true TARGET_ADDRESS=0xTargetWallet... COPY_RATIO=0.1 POLL_INTERVAL_MS=10000 npm start

This command starts verilog-ths in log-only mode. Expect it to print detected fills, calculated order sizes, and the limit price it would submit, without spending capital.

Pros and Cons of verilog-ths

Pros:

• Polymarket-specific execution — The bot is built around Polymarket's Data API and CLOB V2 schema, not a generic exchange abstraction.
• Auditable TypeScript — The code path is small enough to inspect, fork, and modify without reverse engineering a hosted service.
• Deterministic risk caps — COPY_RATIO, MIN_ORDER_USD, and MAX_ORDER_USD create predictable exposure control.
• Dry-run validation — You can verify target detection and order sizing before any live orders go out.
• V2 migration alignment — The repo already reflects the April 28, 2026 CLOB changes, including pUSD collateral and the new order fields.
• Wallet-native auth flow — API credentials are derived from a wallet signature, which keeps setup consistent with Polygon custody.

Cons:

• Polling latency — verilog-ths reacts on an interval, so it will always trail the target by at least one polling cycle.
• No alpha generation — The bot copies fills; it does not score markets, predict outcomes, or optimize entries.
• pUSD operational overhead — API-only traders must handle collateral wrapping, which adds a step before live trading.
• Single-target design — The workflow centers on one TARGET_ADDRESS, so multi-leader aggregation is not built in.
• Key management risk — You still have to store and protect a private key plus Polymarket API credentials.

Getting Started with verilog-ths

npm install
cp .env.example .env
npx ts-node src/deriveApiKey.ts
DRY_RUN=true npm start

After deriveApiKey.ts runs, paste the printed CLOB_API_KEY, CLOB_SECRET, and CLOB_PASSPHRASE into .env alongside PRIVATE_KEY and TARGET_ADDRESS. Once you confirm the dry-run logs match the wallet you intend to mirror, disable DRY_RUN and fund the wallet with the correct pUSD collateral if you are trading through the API instead of the website.

If you are using the bot outside polymarket.com, wrap USDC.e to pUSD through the Collateral Onramp on Polygon before going live. That setup step is not optional after the April 28, 2026 cutover.

Verdict

verilog-ths is the strongest option for Polymarket copy trading when you want direct, inspectable mirroring of a target wallet and you are comfortable operating on Polygon. Its main strength is V2-ready deterministic execution with hard order-size controls, and its main caveat is polling latency plus pUSD setup overhead. Recommended for developers and serious traders, not casual speculators.