GOAT BitVM3 Testnet User Guide

GOAT BitVM3 Testnet enables trust-minimized BTC interoperability between Bitcoin and GOAT Network. Access the current testnet UI at bitvm3-testnet4.goat.network.

BitVM3 is a permissionless bridge design that combines presigned transactions, one-time signatures, and SNARK-based dispute resolution. GOAT BitVM3 extends the base model with faster reimbursement and stronger operator-accountability mechanisms.

This page documents the active GOAT BitVM3 testnet flows. References to GOAT testnet iterations such as "Testnet V3" refer to the testnet release cycle.

What This Guide Covers

Area	Audience
Bridge in / bridge out	End users moving BTC between Bitcoin and GOAT Network
Peg-out	Operators participating in the protocol
Graph states	Users or operators monitoring dispute paths
Node setup	Operators, challengers, and watchtowers

BitVM3 Bridge Guide

BitVM3 Bridge is the user-facing entry point for moving BTC through the BitVM3 flow.

Bridge In

BitVM3 bridge-in screen

Connect both wallets

Connect your BTC wallet and your EVM wallet first.

Choose the amount and Bitcoin fee rate

The Bitcoin fee rate affects how quickly the source transaction confirms.

Wait for committee verification

Move to the next step, then refresh the status until the transaction becomes ready to submit.

Submit and sign

Click Submit, confirm the transaction in your wallet, and pay the required base fee.

Track confirmation

The transfer typically arrives in about 60 minutes, but Bitcoin congestion can extend the timeline.

Bridge Out

BitVM3 bridge-out screen

Connect the EVM and BTC wallets

Make sure the receiving BTC wallet is the one you intend to use for withdrawal.

Enter the amount

Confirm that it satisfies the minimum amount shown in the UI.

Review the transfer details

Double-check the amount, exchange rate, and bridge fee before continuing.

Submit within the valid window

Confirm the transaction in the wallet and pay the GOAT Network gas fee.

Monitor the arrival

Use the history page to follow progress until the BTC lands in the receiving wallet.

History

Every bridge-in and bridge-out transfer appears in the history view for status tracking.

BitVM3 bridge history screen

BitVM3 Peg-out Guide

Peg-out is an operator-oriented flow that redeems PegBTC back to native BTC.

BitVM3 peg-out screen

Connect the EVM wallet

The UI automatically shows the peg-out instances available to the connected operator.

Approve PegBTC

Click Approve and approve the maximum amount you intend to use for the operation.

Submit the peg-out

Return to the UI, click Submit, sign the transaction, and pay the gas fee.

Track the graph

Use BitVM3 Graph and peg-out history to follow reimbursement progress and dispute state.

Verify settlement

When the peg-out completes successfully, the BTC appears in the destination wallet.

BitVM3 Graph States

The BitVM3 graph explains how deposits, challenges, and reimbursements evolve on-chain.

BitVM3 graph overview

Case	Status	Meaning
Initial state	Pending peg-out / active deposits	Funds are locked and no operator has started reimbursement yet
Standard path	Withdrawal completed (`Take-1`)	No valid challenge was raised during the first time-lock
Challenge succeeds	Withdrawal intercepted (`Disprove`)	Operator misconduct was proven and collateral was slashed
Challenge fails	Withdrawal finalized (`Take-2`)	Operator defended the withdrawal and completed reimbursement

Join GOAT BitVM3 Testnet

Role Requirements

Role	Requirements
Watchtower	Committee-approved role, enough L1 balance for roughly `4,000 sats` per challenge
Verifier	Permissioned role, enough balance for bond and transaction fees
Operator	Permissionless role, must prepay graph fees on L1 and stake PBTC on L2

Operator funding and staking requirements

Layer	Requirement
Bitcoin L1	Prepay roughly `10,000 sats` per graph and keep at least `50,000 sats` available at startup
GOAT Network L2	Stake WGBTC; the effective minimum locked stake is `0.06 WGBTC`

Contract	Address
Testnet Gateway	`0x440c6dCA87C3511E1eBf4FDB1f584ddaA49dD029`
Testnet StakeManagement	`0x4B6BD356FE9Ad077c6E3691BB2838e814B3F4032`
Testnet WGBTC	`0xbC10000000000000000000000000000000000000`

Staking flow

Operator staking flow

stakeManagement.registerPubkey(xonlyPubkey);
WGBTC.approve(stakeManagementAddress, amount);
stakeManagement.stake(amount);
stakeManagement.lockStake(amount);

A compressed public key is 33 bytes and usually starts with 02 or 03. The x-only public key is the 32-byte suffix after removing that prefix.

Verifier registration

Verifier registration uses the node's libp2p PEER_ID, not its Bitcoin public key.

Complete the installation, then run bitvm-noded key peer as described in Generate Peer Key.
Keep PEER_KEY private and use it in the Verifier .env. Submit only the public PEER_ID to the official governance or contract administrator.
Wait for the administrator to add the PEER_ID to the CommitteeManagement Verifier allowlist.
Before starting the node, confirm that isVerifier(bytes peerId) returns true. The node must use the same PEER_KEY that generated the registered PEER_ID.

Run a BitVM3 Node

Recommended Machine Configuration

Role	CPU	RAM	Disk
Operator	32 vCPU (min)	32 GiB (min)	500 GB
Verifier	32 vCPU (min)	32 GiB (min)	500 GB

RAM is dominated by fixed costs rather than batch_size — at batch_size=100 this peaks at ~32 GiB; larger batch sizes need more RAM, while more vCPUs mainly increase throughput. After peg-in, Verifier storage needs drop to ~26 KB; Operator retains ~23.4 GiB until peg-out.

Example AWS c7a instances sized for this workload:

Instance	vCPUs	RAM	Effective batch_size	Peak RAM
`c7a.8xlarge`	32	64 GiB	32	28.65 GiB
`c7a.16xlarge`	64	128 GiB	64	30.08 GiB
`c7a.32xlarge`	128	256 GiB	100	31.68 GiB
`c7a.48xlarge`	192	384 GiB	192	35.78 GiB

Installation

Ensure the ZKM toolchain is installed. See ProjectZKM/toolchain, then confirm ~/.zkm-toolchain/env exists.

Install from source

source ~/.zkm-toolchain/env
cargo install --git https://github.com/GOATNetwork/bitvm2-node bitvm-noded

Download a release from bitvm-noded releases and verify the version after installation.

After the installation, run the bitvm-noded --version to check that the version should be 0.4.0.

$ bitvm-noded --version
bitvm-noded 0.4.0

Generate Peer Key

Generate one peer key per node:

$ bitvm-noded key peer
PEER_KEY=
PEER_ID=

Use PEER_KEY in the node .env.

Prepare GC Artifacts

Operator and Verifier nodes must have the GC artifacts on disk before running C&C. Point the runtime to those files with:

FGC_GATES_PATH=
FGC_OUT_INDICES_PATH=
SGC_GATES_PATH=
SGC_OUT_INDICES_PATH=
FGC_COMPACT_GATES_PATH=
FGC_COMPACT_OUT_INDICES_PATH=
SGC_COMPACT_GATES_PATH=
SGC_COMPACT_OUT_INDICES_PATH=

Funding Address

Set BITVM_SECRET to your hex-format private key, then deposit tBTC4 (Bitcoin Testnet4) to the generated P2WSH address:

$ bitvm-noded key funding-address
Funding P2WSH address (for operator and verifier): tb1q...

Operator Node Deployment

Create an Operator .env:

RUST_LOG=info
ACTOR=Operator

BTC_CHAIN_URL=https://mempool.space/testnet4/api
GOAT_PROOF_BUILD_URL=http://16.146.8.146:8900

GOAT_GATEWAY_CONTRACT_ADDRESS=
GOAT_GATEWAY_EVENT_THE_GRAPH_URL=
GOAT_GATEWAY_EVENT_FILTER_FROM=
GOAT_SWAP_CONTRACT_ADDRESS=0x3FbbA0eb82cf1247cbf92B3D51641226310F0Ca5
GOAT_SWAP_EVENT_THE_GRAPH_URL=https://graph.goat.network/subgraphs/name/bitvm2_escrow_manager_0x3Fbb
GOAT_SWAP_EVENT_FILTER_FROM=14587962

GOAT_CHAIN_URL=https://rpc.testnet3.goat.network
PEER_KEY=
BITVM_SECRET=
GOAT_ADDRESS=
PROTO_NAME=bitvm2t4
BOOTNODES=/ip4/16.146.8.146/tcp/8445/p2p/12D3KooWCrPTAmhFdC5DBGgkxZvJi6iuSeiDWKRL87isrt4iMHXv

SOLDERING_PROOF_PAYLOAD_STORE_PATH=

OPERATOR_VK_HASH=0x00d9cbe73ff862786141fb11376884c0052ae94631ad97bfc892e01680d623fe
OPERATOR_ZKM_VERSION=v1.2.5
GENESIS_SEQUENCER_COMMIT_TXID=9c730b76ee4793248a3b1e605745f0c102207f60eb5023850e3e121c5f539303

CAC_BATCH_SIZE=100

FGC_GATES_PATH=
FGC_OUT_INDICES_PATH=
SGC_GATES_PATH=
SGC_OUT_INDICES_PATH=
FGC_COMPACT_GATES_PATH=
FGC_COMPACT_OUT_INDICES_PATH=
SGC_COMPACT_GATES_PATH=
SGC_COMPACT_OUT_INDICES_PATH=

Start the Operator:

./bitvm-noded \
  --rpc-addr 0.0.0.0:8901 \
  --p2p-port 8445 \
  --db-path sqlite:./operator.db \
  --bootnodes /ip4/16.146.8.146/tcp/8445/p2p/12D3KooWCrPTAmhFdC5DBGgkxZvJi6iuSeiDWKRL87isrt4iMHXv

Verifier Node Deployment

Create a Verifier .env:

RUST_LOG=info
ACTOR=Verifier

BITCOIN_NETWORK=testnet4
BTC_CHAIN_URL=https://mempool.space/testnet4/api

GOAT_GATEWAY_CONTRACT_ADDRESS=
GOAT_GATEWAY_EVENT_THE_GRAPH_URL=
GOAT_GATEWAY_EVENT_FILTER_FROM=
GOAT_SWAP_CONTRACT_ADDRESS=0x3FbbA0eb82cf1247cbf92B3D51641226310F0Ca5
GOAT_SWAP_EVENT_THE_GRAPH_URL=https://graph.goat.network/subgraphs/name/bitvm2_escrow_manager_0x3Fbb
GOAT_SWAP_EVENT_FILTER_FROM=14587962

GOAT_CHAIN_URL=https://rpc.testnet3.goat.network
GOAT_ADDRESS=
PEER_KEY=
BITVM_SECRET=
PROTO_NAME=bitvm2t4
BOOTNODES=/ip4/16.146.8.146/tcp/8445/p2p/12D3KooWCrPTAmhFdC5DBGgkxZvJi6iuSeiDWKRL87isrt4iMHXv

OPERATOR_VK_HASH=0x00d9cbe73ff862786141fb11376884c0052ae94631ad97bfc892e01680d623fe
OPERATOR_ZKM_VERSION=v1.2.5
GENESIS_SEQUENCER_COMMIT_TXID=9c730b76ee4793248a3b1e605745f0c102207f60eb5023850e3e121c5f539303

SOLDERING_PROOF_PAYLOAD_STORE_PATH=
CAC_BATCH_SIZE=100

FGC_GATES_PATH=
FGC_OUT_INDICES_PATH=
SGC_GATES_PATH=
SGC_OUT_INDICES_PATH=
FGC_COMPACT_GATES_PATH=
FGC_COMPACT_OUT_INDICES_PATH=
SGC_COMPACT_GATES_PATH=
SGC_COMPACT_OUT_INDICES_PATH=

Start the Verifier:

./bitvm-noded \
  --rpc-addr 0.0.0.0:8902 \
  --p2p-port 8446 \
  --db-path sqlite:./verifier.db \
  --bootnodes /ip4/16.146.8.146/tcp/8445/p2p/12D3KooWCrPTAmhFdC5DBGgkxZvJi6iuSeiDWKRL87isrt4iMHXv

Operate with Agent Skills

If you prefer an agent-driven workflow, the BitVM3 node repository also publishes operation documents for common tasks.

Agent skill	Purpose	Command document
`/run-operator-node`	Start an operator node	`run-operator-node.md`
`/pegin-request`	Request, prepare, or cancel a peg-in	`pegin-request.md`
`/pegout`	Initiate peg-out as an operator	`pegout.md`
`/bridge-out`	Initiate bridge-out flow	`bridge-out.md`
`/challenge`	Broadcast a challenge transaction	`challenge.md`

On this page