diff --git a/.gitignore b/.gitignore
index 0e82613dfd..f26121387e 100644
--- a/.gitignore
+++ b/.gitignore
@@ -49,3 +49,5 @@ client/cmd/translationsreport/translationsreport
 client/cmd/translationsreport/worksheets
 server/cmd/dexadm/dexadm
 server/cmd/geogame/geogame
+internal/libsecp256k1/secp256k1
+internal/cmd/xmrswap/xmrswap
diff --git a/dex/testing/xmr/README.md b/dex/testing/xmr/README.md
new file mode 100644
index 0000000000..30df8ab7cd
--- /dev/null
+++ b/dex/testing/xmr/README.md
@@ -0,0 +1,244 @@
+# Monero Development Harness
+
+Monero development Harness - documentation and notes
+
+## Useful Info
+
+Monero is very different than btc in that it does not provide a single rpc
+tool like `bitcoin-cli` but rather a set of json 2.0 & other older json apis
+which can be accessed by sending curl requests for each one.
+
+Monero wallets are accounts based
+
+<https://web.getmonero.org/resources/moneropedia/account.html>
+
+## Architecture
+
+![alt text](image-1.png)
+
+Embedded in Tmux
+
+- **alpha** is a monero p2p daemon
+
+- **bill** is a miner wallet .. you can top up more funds from bill if you run out
+
+- **fred** is a normal wallet user
+
+- **charlie** is a normal wallet user
+
+- **charlie_view** is a view-only wallet sibling of charlie full wallet - no spend key
+
+## Using
+
+### Prerequisites
+
+- **monero-x86_64-linux-gnu-v0.18.3.3** or later <https://downloads.getmonero.org/cli/linux64>
+- **linux** (tested on Ubuntu 22.04)
+- **jq** (1.6)
+
+### Setup
+
+**monero-x86_64-linux-gnu-v0.18.3.3** should be in PATH
+
+`export PATH=$PATH:[path-to]/monero-x86_64-linux-gnu-v0.18.3.3`
+
+### Background Mining
+
+By default background mining is set up and mines to bill wallet every 15s
+
+To disable:
+
+`export NOMINER="1" to your shell`
+
+ or else invoke the harness with:
+
+`NOMINER="1" ./harness.sh`
+
+You should disable if attempting the manual offline cold signing using `monero-wallet-cli`
+
+You should also ctl-C charlie & charlie_view wallets for this
+
+### Run
+
+`./harness.sh`
+
+### Data Directory
+
+![alt text](image-2.png)
+
+### Known Issues
+
+The transaction spend locking needs more investigation
+
+### Commands Help
+
+run `./help` from the tmux harness window 0
+
+```text
+
+Commands Help:
+--------------
+alpha_get_transactions
+
+- get transactions info for one or more txid
+- inputs:
+  - tx_hashes - hash1,hash2,hash3,...
+
+alpha_get_transactions_details
+
+- get transaction development details from monerod including tx lock time
+- inputs:
+  - tx_hashes - hash1,hash2,hash3,...
+
+alpha_info
+
+- get running daemon details - height, etc.
+- inputs: None
+
+alpha_sendrawtransaction
+
+- broadcast a previously built signed tx
+- inputs:
+  - tx_as_hex string - can be generated with charlie_build_tx or fred_build_tx
+
+alpha_transaction_pool
+
+- get mempool details
+- inputs: None
+
+mine-to-bill
+
+- generate 1 or more blocks to bill wallet
+- inputs:
+  - num_blocks - defaults to 1
+
+bill_balance
+
+- get bill wallet balance details
+- inputs: None
+
+bill_refresh_wallet
+
+- update bill's wallet from the daemon latest info
+- inputs: None
+
+bill_transfer_to
+
+- build, sign and broadcast a transaction from bill wallet to another address
+- inputs:
+  - amount in in atomic units 1e12 - e.g. 1230000000000 echo = 1.23 XMR
+  - address - recipient primary address - account index 0, subaddr_indeces [0]
+  - unlock_time - unlock after n blocks and make spendable - defaults to 0 (no lock)
+
+charlie_balance
+
+- get charlie wallet balance details
+- inputs: None
+
+charlie_refresh_wallet
+
+- update charlie's wallet from the daemon latest info
+- inputs: None
+
+charlie_build_tx
+
+- build a signed tx for later broadcasting using alpha_send
+- inputs:
+  - amount in in atomic units 1e12 - e.g. 1230000000000 = 1.23 XMR
+  - address - recipient primary address - account index 0, subaddr_indeces [0]
+  - unlock_time - unlock after n blocks and make spendable - defaults to 0 (no lock)
+-outputs:
+  - signed tx_blob
+  - tx_hash
+
+charlie_incoming_transfers
+
+- get a list of incoming mined transfers to charlie wallet
+- inputs: None
+
+charlie_transfer_to
+
+- build, sign and broadcast a transaction from charlie wallet to another address
+- inputs
+  - amount in in atomic units 1e12 - e.g. 1230000000000 echo = 1.23 XMR
+  - address - recipient primary address - account index 0, subaddr_indeces [0]
+  - unlock_time - unlock after n blocks and make spendable - defaults to 0 (no lock)
+
+fred_export_outputs
+
+- export fred outputs hex
+- input:
+  - all - defaults to true - otherwise only new outputs since the last call
+
+charlie_export_outputs
+
+- export charlie outputs hex
+- input:
+  - all - defaults to true - otherwise only new outputs since the last call
+
+charlie_view_export_outputs
+
+- export charlie_view outputs hex - charlie_view knows the outputs but has no spend key
+- inputs: None
+- only useful in offline, cold signing process using monero-wallet-cli interactive tool
+  must be hex decoded into a file to use in monero-wallet-cli
+
+fred_export_key_images
+
+- export signed key images from fred wallet - an array of key images and ephemeral signatures
+- input:
+  - all - defaults to true - otherwise only new key images since the last call
+
+charlie_export_key_images
+
+- export signed key images from charlie wallet - an array of key images and ephemeral signatures
+- input:
+  - all - defaults to true - otherwise only new key images since the last call
+
+fred_balance
+
+- get fred wallet balance details
+- inputs: None
+
+fred_refresh_wallet
+
+- update fred's wallet from the daemon latest info
+- inputs: None
+
+fred_build_tx
+
+- build a signed tx for later broadcasting using alpha_send
+- inputs:
+  - amount in in atomic units 1e12 - e.g. 1230000000000 = 1.23 XMR
+  - address - recipient primary address - account index 0, subaddr_indeces [0]
+  - unlock_time - unlock after n blocks and make spendable - defaults to 0 (no lock)
+-outputs:
+  - signed tx_blob
+  - tx_hash
+
+fred_incoming_transfers
+
+- get a list of incoming mined transfers to fred wallet
+- inputs: None
+
+fred_transfer_to
+
+- build, sign and broadcast a transaction from bill wallet to another address
+- inputs
+  - amount in in atomic units 1e12 - e.g. 1230000000000 echo = 1.23 XMR
+  - address - recipient primary address - account index 0, subaddr_indeces [0]
+  - unlock_time - unlock after n blocks and make spendable - defaults to 0 (no lock)
+
+wallets
+
+- wallet details exported to the harness environment - useful for building commands in the harness window 0
+
+help
+
+- this help
+
+quit
+
+- shutdown daemons and quit the harness
+
+```
diff --git a/dex/testing/xmr/harness.sh b/dex/testing/xmr/harness.sh
new file mode 100755
index 0000000000..ee70a4ccf1
--- /dev/null
+++ b/dex/testing/xmr/harness.sh
@@ -0,0 +1,638 @@
+#!/usr/bin/env bash
+# Tmux script that sets up an XMR regtest harness with one node 'alpha' and 3
+# wallets 'fred', 'bill' & 'charlie'. Charlie also has a View-Only sibling.
+#
+# There is now a new monero-wallet-rpc server with no attached wallet. This is
+# for programmatically creating and using a new wallet. The wallet will be gen-
+# erated in "own" directory but can be named whatever you need - maybe "alice",
+# "Bob" or "carol"
+
+################################################################################
+# Development
+################################################################################
+
+# export PATH=$PATH:~/monero-x86_64-linux-gnu-v0.18.3.3
+
+################################################################################
+# Monero RPC functions
+################################################################################
+
+source monero_functions
+
+################################################################################
+# Start up
+################################################################################
+
+set -evx
+
+RPC_USER="user"
+RPC_PASS="pass"
+WALLET_PASS=abc
+
+LOCALHOST="127.0.0.1"
+
+# p2p listen and rpc listen ports for alpha node
+export ALPHA_NODE_PORT="18080"
+export ALPHA_NODE_RPC_PORT="18081"
+
+# for multinode - not used for singlenode
+export ALPHA_NODE="${LOCALHOST}:${ALPHA_NODE_PORT}"
+
+# wallet servers' listen rpc ports
+export FRED_WALLET_RPC_PORT="28084"
+export BILL_WALLET_RPC_PORT="28184"
+export CHARLIE_WALLET_RPC_PORT="28284"
+export CHARLIE_VIEW_WALLET_RPC_PORT="28384"
+export OWN_WALLET_RPC_PORT="28484"
+
+# wallet seeds, passwords & primary addresses
+FRED_WALLET_SEED="vibrate fever timber cuffs hunter terminal dilute losing light because nabbing slower royal brunt gnaw vats fishing tipsy toxic vague oscar fudge mice nasty light"
+export FRED_WALLET_NAME="fred"
+export FRED_WALLET_PASS=""
+export FRED_WALLET_PRIMARY_ADDRESS="494aSG3QY1C4PJf7YyDjFc9n2uAuARWSoGQ3hrgPWXtEjgGrYDn2iUw8WJP5Dzm4GuMkY332N9WfbaKfu5tWM3wk8ZeSEC5"
+
+BILL_WALLET_SEED="zodiac playful artistic friendly ought myriad entrance inroads mural duets enraged furnished tsunami pimple ammo prying january swiftly pulp aunt beer ticket tubes unplugs ammo"
+export BILL_WALLET_NAME="bill"
+export BILL_WALLET_PASS=""
+export BILL_WALLET_PRIMARY_ADDRESS="42xPx5nWhxegefWEzRNoJZWwK7d5ofKoWLG1Gmf8567nJMVR37P1EvqYxqWtfgtYUn8qgSbeAqoLcLKe3seFXV2k5ZSqvQw"
+
+CHARLIE_WALLET_SEED="tilt equip bikini nylon ardent asylum eight vane gyrate venomous dove vortex aztec maul rash lair elope rover lodge neutral lemon eggs mocked mugged equip"
+export CHARLIE_WALLET_NAME="charlie"
+export CHARLIE_WALLET_PASS=""
+export CHARLIE_WALLET_PRIMARY_ADDRESS="453w1dEoNE1HjKzKVpAU14Honzenqs5VKKQWHb7RuNHLa4ekXhXnGhR6RuttNpvjbtDjzy8pTgz5j4ZSsWQqyxSDBVQ4WCk"
+export CHARLIE_WALLET_VIEWKEY="ff3bef320b8268cef410b78c91f34dfc995c72fcb1b498f7a732d76a42a9e207"
+export CHARLIE_VIEW_WALLET_NAME="charlie_view"
+
+# data dir
+NODES_ROOT=~/dextest/xmr
+FRED_WALLET_DIR="${NODES_ROOT}/wallets/fred"
+BILL_WALLET_DIR="${NODES_ROOT}/wallets/bill"
+CHARLIE_WALLET_DIR="${NODES_ROOT}/wallets/charlie"
+CHARLIE_VIEW_WALLET_DIR="${NODES_ROOT}/wallets/charlie_view"
+OWN_WALLET_DIR="${NODES_ROOT}/wallets/own"
+HARNESS_CTL_DIR="${NODES_ROOT}/harness-ctl"
+ALPHA_DATA_DIR="${NODES_ROOT}/alpha"
+ALPHA_REGTEST_CFG="${ALPHA_DATA_DIR}/alpha.conf"
+
+if [ -d "${NODES_ROOT}" ]; then
+  rm -fR "${NODES_ROOT}"
+fi
+mkdir -p "${FRED_WALLET_DIR}"
+mkdir -p "${BILL_WALLET_DIR}"
+mkdir -p "${CHARLIE_WALLET_DIR}"
+mkdir -p "${CHARLIE_VIEW_WALLET_DIR}"
+mkdir -p "${OWN_WALLET_DIR}"
+mkdir -p "${HARNESS_CTL_DIR}"
+mkdir -p "${ALPHA_DATA_DIR}"
+touch    "${ALPHA_REGTEST_CFG}"
+
+# make available from the harness-ctl dir 
+cp monero_functions ${HARNESS_CTL_DIR} 
+
+# Background watch mining in window 7 by default:
+# 'export NOMINER="1"' or uncomment this line to disable
+#NOMINER="1"
+
+################################################################################
+# Control Scripts
+################################################################################
+echo "Writing ctl scripts"
+
+# Daemon info
+cat > "${HARNESS_CTL_DIR}/alpha_info" <<EOF
+#!/usr/bin/env bash
+source monero_functions
+get_info ${ALPHA_NODE_RPC_PORT}
+EOF
+chmod +x "${HARNESS_CTL_DIR}/alpha_info"
+# -----------------------------------------------------------------------------
+
+# Send a raw signed tx to monerod
+# inputs:
+# - tx as hex (from tx_blob returned by <wallet_name>_build_tx)
+# - do_not_relay to other nodes - defaults to false
+cat > "${HARNESS_CTL_DIR}/alpha_sendrawtransaction" <<EOF
+#!/usr/bin/env bash
+source monero_functions
+sendrawtransaction ${ALPHA_NODE_RPC_PORT} \$1 \$2 2>/dev/null
+EOF
+chmod +x "${HARNESS_CTL_DIR}/alpha_sendrawtransaction"
+# -----------------------------------------------------------------------------
+
+# Get one or more transaction details from monerod
+# inputs:
+# - txids as hex string - "hash1,hash2,hash3,..."
+# - decode_as_json - defaults to false
+cat > "${HARNESS_CTL_DIR}/alpha_get_transactions" <<EOF
+#!/usr/bin/env bash
+source monero_functions
+get_transactions ${ALPHA_NODE_RPC_PORT} \$1 \$2 2>/dev/null
+EOF
+chmod +x "${HARNESS_CTL_DIR}/alpha_get_transactions"
+# -----------------------------------------------------------------------------
+
+# Get one or more transaction development details from monerod including tx lock time
+# inputs:
+# - txids as hex string - "hash1,hash2,hash3,..."
+cat > "${HARNESS_CTL_DIR}/alpha_get_transactions_details" <<EOF
+#!/usr/bin/env bash
+source monero_functions
+get_transactions ${ALPHA_NODE_RPC_PORT} \$1 true 2>/dev/null | jq '.txs[] | .as_json | fromjson'
+EOF
+chmod +x "${HARNESS_CTL_DIR}/alpha_get_transactions_details"
+# -----------------------------------------------------------------------------
+
+# Mempool info
+cat > "${HARNESS_CTL_DIR}/alpha_transaction_pool" <<EOF
+#!/usr/bin/env bash
+source monero_functions
+get_transaction_pool ${ALPHA_NODE_RPC_PORT} 2>/dev/null
+EOF
+chmod +x "${HARNESS_CTL_DIR}/alpha_transaction_pool"
+# -----------------------------------------------------------------------------
+
+# Mine to bill-the-miner
+# inputs:
+# - number of blocks to mine
+cat > "${HARNESS_CTL_DIR}/mine-to-bill" <<EOF
+#!/usr/bin/env bash
+source monero_functions
+generate ${BILL_WALLET_PRIMARY_ADDRESS} ${ALPHA_NODE_RPC_PORT} \$1
+sleep 1
+EOF
+chmod +x "${HARNESS_CTL_DIR}/mine-to-bill"
+# -----------------------------------------------------------------------------
+
+# Send funds from fred's primary account address to another address
+# inputs:
+# - money in atomic units 1e12
+# - recipient monero address
+# - lock time in blocks after which the money can be spent (defaults to 0; no locking)
+cat > "${HARNESS_CTL_DIR}/fred_transfer_to" <<EOF
+#!/usr/bin/env bash
+source monero_functions
+transfer_simple ${FRED_WALLET_RPC_PORT} \$1 \$2 \$3
+sleep 0.5
+EOF
+chmod +x "${HARNESS_CTL_DIR}/fred_transfer_to"
+# -----------------------------------------------------------------------------
+
+# Send funds from bill's primary account address to another address
+# inputs:
+# - money in atomic units 1e12
+# - recipient monero address
+# - lock time in blocks after which the money can be spent (defaults to 0; no locking)
+cat > "${HARNESS_CTL_DIR}/bill_transfer_to" <<EOF
+#!/usr/bin/env bash
+source monero_functions
+transfer_simple ${BILL_WALLET_RPC_PORT} \$1 \$2 \$3
+sleep 0.5
+EOF
+chmod +x "${HARNESS_CTL_DIR}/bill_transfer_to"
+# -----------------------------------------------------------------------------
+
+# Send funds from charlie's primary account address to another address
+# inputs:
+# - money in atomic units 1e12
+# - recipient monero address
+# - lock time in blocks after which the money can be spent (defaults to 0; no locking)
+cat > "${HARNESS_CTL_DIR}/charlie_transfer_to" <<EOF
+#!/usr/bin/env bash
+source monero_functions
+transfer_simple ${CHARLIE_WALLET_RPC_PORT} \$1 \$2 \$3
+sleep 0.5
+EOF
+chmod +x "${HARNESS_CTL_DIR}/charlie_transfer_to"
+# -----------------------------------------------------------------------------
+
+# Get fred's balance from an account
+# input
+# - account number - defaults to account 0
+cat > "${HARNESS_CTL_DIR}/fred_balance" <<EOF
+#!/usr/bin/env bash
+source monero_functions
+get_balance ${FRED_WALLET_RPC_PORT} \$1
+EOF
+chmod +x "${HARNESS_CTL_DIR}/fred_balance"
+# -----------------------------------------------------------------------------
+
+# Get bill's balance from an account
+# input
+# - account number - defaults to account 0
+cat > "${HARNESS_CTL_DIR}/bill_balance" <<EOF
+#!/usr/bin/env bash
+source monero_functions
+get_balance ${BILL_WALLET_RPC_PORT} \$1
+EOF
+chmod +x "${HARNESS_CTL_DIR}/bill_balance"
+# -----------------------------------------------------------------------------
+
+# Get charlie's balance from an account
+# input
+# - account number - defaults to account 0
+cat > "${HARNESS_CTL_DIR}/charlie_balance" <<EOF
+#!/usr/bin/env bash
+source monero_functions
+get_balance ${CHARLIE_WALLET_RPC_PORT} \$1
+EOF
+chmod +x "${HARNESS_CTL_DIR}/charlie_balance"
+# -----------------------------------------------------------------------------
+
+# Update fred's wallet from the daemon latest info
+cat > "${HARNESS_CTL_DIR}/fred_refresh_wallet" <<EOF
+#!/usr/bin/env bash
+source monero_functions
+refresh_wallet ${FRED_WALLET_RPC_PORT}
+EOF
+chmod +x "${HARNESS_CTL_DIR}/fred_refresh_wallet"
+# -----------------------------------------------------------------------------
+
+# Update bill's wallet from the daemon latest info
+cat > "${HARNESS_CTL_DIR}/bill_refresh_wallet" <<EOF
+#!/usr/bin/env bash
+source monero_functions
+refresh_wallet ${BILL_WALLET_RPC_PORT}
+EOF
+chmod +x "${HARNESS_CTL_DIR}/bill_refresh_wallet"
+# -----------------------------------------------------------------------------
+
+# Update charlie's wallet from the daemon latest info
+cat > "${HARNESS_CTL_DIR}/charlie_refresh_wallet" <<EOF
+#!/usr/bin/env bash
+source monero_functions
+refresh_wallet ${CHARLIE_WALLET_RPC_PORT}
+EOF
+chmod +x "${HARNESS_CTL_DIR}/charlie_refresh_wallet"
+# -----------------------------------------------------------------------------
+
+# Get incoming transfers to fred's wallet
+# input
+# - transfer_type - defualts to "all"
+cat > "${HARNESS_CTL_DIR}/fred_incoming_transfers" <<EOF
+#!/usr/bin/env bash
+source monero_functions
+incoming_transfers ${FRED_WALLET_RPC_PORT} \$1
+EOF
+chmod +x "${HARNESS_CTL_DIR}/fred_incoming_transfers"
+# -----------------------------------------------------------------------------
+
+# Get incoming transfers to charlie's wallet
+# input
+# - transfer_type - defaults to "all"
+cat > "${HARNESS_CTL_DIR}/charlie_incoming_transfers" <<EOF
+#!/usr/bin/env bash
+source monero_functions
+incoming_transfers ${CHARLIE_WALLET_RPC_PORT} \$1
+EOF
+chmod +x "${HARNESS_CTL_DIR}/charlie_incoming_transfers"
+# -----------------------------------------------------------------------------
+
+# Export outputs from fred wallet - outputs data hex
+# input:
+# - all - defaults to true - otherwise only new outputs since the last call
+cat > "${HARNESS_CTL_DIR}/fred_export_outputs" <<EOF
+#!/usr/bin/env bash
+source monero_functions
+export_outputs ${FRED_WALLET_RPC_PORT} \$1
+EOF
+chmod +x "${HARNESS_CTL_DIR}/fred_export_outputs"
+# -----------------------------------------------------------------------------
+
+# Export outputs from charlie wallet - outputs data hex
+# input:
+# - all - defaults to true - otherwise only new outputs since the last call
+cat > "${HARNESS_CTL_DIR}/charlie_export_outputs" <<EOF
+#!/usr/bin/env bash
+source monero_functions
+export_outputs ${CHARLIE_WALLET_RPC_PORT} \$1
+EOF
+chmod +x "${HARNESS_CTL_DIR}/charlie_export_outputs"
+# -----------------------------------------------------------------------------
+
+# Export outputs from charlie view wallet for offline signing - array of key images and ephemeral signatures
+# input:
+# - all - defaults to true - otherwise only new outputs since the last call .. not useful for view wallet
+cat > "${HARNESS_CTL_DIR}/charlie_view_export_outputs" <<EOF
+#!/usr/bin/env bash
+source monero_functions
+export_outputs ${CHARLIE_VIEW_WALLET_RPC_PORT} \$1
+EOF
+chmod +x "${HARNESS_CTL_DIR}/charlie_view_export_outputs"
+# -----------------------------------------------------------------------------
+
+# Export signed key images from fred wallet - array of key images and ephemeral signatures
+# input:
+# - all - defaults to true - otherwise only new outputs since the last call
+cat > "${HARNESS_CTL_DIR}/fred_export_key_images" <<EOF
+#!/usr/bin/env bash
+source monero_functions
+export_key_images ${FRED_WALLET_RPC_PORT} \$1
+EOF
+chmod +x "${HARNESS_CTL_DIR}/fred_export_key_images"
+# -----------------------------------------------------------------------------
+
+# Export signed key images from charlie wallet - array of key images and ephemeral signatures
+# input:
+# - all - defaults to true - otherwise only new outputs since the last call
+cat > "${HARNESS_CTL_DIR}/charlie_export_key_images" <<EOF
+#!/usr/bin/env bash
+source monero_functions
+export_key_images ${CHARLIE_WALLET_RPC_PORT} \$1
+EOF
+chmod +x "${HARNESS_CTL_DIR}/charlie_export_key_images"
+# -----------------------------------------------------------------------------
+
+# Build a signed tx with fred wallet
+# inputs
+# - money in atomic units 1e12
+# - recipient monero address
+# - lock time in blocks after which the money can be spent (defaults to 0; no locking)
+# outputs:
+# - tx_blob
+# - tx_hash
+cat > "${HARNESS_CTL_DIR}/fred_build_tx" <<EOF
+#!/usr/bin/env bash
+source monero_functions
+transfer_no_relay ${FRED_WALLET_RPC_PORT} \$1 \$2 \$3 | jq -nr '[inputs] | add | .result.tx_blob, .result.tx_hash'
+EOF
+chmod +x "${HARNESS_CTL_DIR}/fred_build_tx"
+# -----------------------------------------------------------------------------
+
+# Build a signed tx with charlie wallet
+# inputs
+# - money in atomic units 1e12
+# - recipient monero address
+# - lock time in blocks after which the money can be spent (defaults to 0; no locking)
+# outputs:
+# - tx_blob
+# - tx_hash
+cat > "${HARNESS_CTL_DIR}/charlie_build_tx" <<EOF
+#!/usr/bin/env bash
+source monero_functions
+transfer_no_relay ${CHARLIE_WALLET_RPC_PORT} \$1 \$2 \$3 | jq -nr '[inputs] | add | .result.tx_blob, .result.tx_hash'
+EOF
+chmod +x "${HARNESS_CTL_DIR}/charlie_build_tx"
+# -----------------------------------------------------------------------------
+
+# Get basic info on all wallets from env which can be used in the scripts above
+cat > "${HARNESS_CTL_DIR}/wallets" <<EOF
+#!/usr/bin/env bash
+env | grep FRED
+env | grep BILL
+env | grep CHARLIE
+env | grep OWN
+EOF
+chmod +x "${HARNESS_CTL_DIR}/wallets"
+# -----------------------------------------------------------------------------
+
+# Shutdown script
+cat > "${NODES_ROOT}/harness-ctl/quit" <<EOF
+#!/usr/bin/env bash
+if [ -z "$NOMINER" ]
+then
+   tmux send-keys -t $SESSION:7 C-c
+fi
+sleep 0.05
+tmux send-keys -t $SESSION:6 C-c
+sleep 0.05
+tmux send-keys -t $SESSION:5 C-c
+sleep 0.05
+tmux send-keys -t $SESSION:4 C-c
+sleep 0.05
+tmux send-keys -t $SESSION:3 C-c
+sleep 0.05
+tmux send-keys -t $SESSION:2 C-c
+sleep 0.05
+tmux send-keys -t $SESSION:1 C-c
+sleep 0.05
+tmux kill-session
+sleep 0.05
+EOF
+chmod +x "${HARNESS_CTL_DIR}/quit"
+# -----------------------------------------------------------------------------
+
+# Commands help
+cat > "${NODES_ROOT}/harness-ctl/help" <<EOF
+#!/usr/bin/env bash
+source monero_functions
+cmd_help | less
+EOF
+chmod +x "${HARNESS_CTL_DIR}/help"
+# -----------------------------------------------------------------------------
+
+################################################################################
+# Configuration Files
+################################################################################
+echo "Writing alpha node config file ${ALPHA_REGTEST_CFG}"
+
+cat > "${ALPHA_REGTEST_CFG}" <<EOF
+regtest=1
+offline=1
+data-dir=${ALPHA_DATA_DIR}
+rpc-bind-ip=127.0.0.1
+rpc-bind-port=${ALPHA_NODE_RPC_PORT}
+fixed-difficulty=1
+log-level=1
+EOF
+
+################################################################################
+# Start tmux harness
+################################################################################
+echo "Starting harness"
+
+SESSION="xmr-harness"
+
+tmux new-session -d -s $SESSION $SHELL
+tmux rename-window -t $SESSION:0 "harness-ctl"
+tmux send-keys -t $SESSION:0 "set +o history" C-m
+tmux send-keys -t $SESSION:0 "cd ${HARNESS_CTL_DIR}" C-m
+
+################################################################################
+# SINGLE NODE
+################################################################################
+
+# start alpha node - window 1
+echo "starting singlenode alpha with config-file: ${ALPHA_REGTEST_CFG}"
+
+tmux new-window -t $SESSION:1 -n 'alpha' $SHELL
+tmux send-keys -t $SESSION:1 "set +o history" C-m
+tmux send-keys -t $SESSION:1 "cd ${ALPHA_DATA_DIR}" C-m
+
+tmux send-keys -t $SESSION:1 "monerod --config-file=${ALPHA_REGTEST_CFG}; tmux wait-for -S alphaxmr" C-m
+
+sleep 5
+
+get_info ${ALPHA_NODE_RPC_PORT}
+
+################################################################################
+# WALLET SERVERS
+################################################################################
+
+# Start the first wallet server - window 2
+echo "starting fred wallet server"
+
+tmux new-window -t $SESSION:2 -n 'fred' $SHELL
+tmux send-keys -t $SESSION:2 "set +o history" C-m
+tmux send-keys -t $SESSION:2 "cd ${FRED_WALLET_DIR}" C-m
+
+tmux send-keys -t $SESSION:2 "monero-wallet-rpc \
+   --rpc-bind-ip 127.0.0.1 \
+   --rpc-bind-port ${FRED_WALLET_RPC_PORT} \
+   --wallet-dir ${FRED_WALLET_DIR} \
+   --disable-rpc-login \
+   --allow-mismatched-daemon-version; tmux wait-for -S fredxmr" C-m
+
+sleep 2
+
+# Start the second wallet server - window 3
+echo "starting bill wallet server"
+
+tmux new-window -t $SESSION:3 -n 'bill' $SHELL
+tmux send-keys -t $SESSION:3 "set +o history" C-m
+tmux send-keys -t $SESSION:3 "cd ${BILL_WALLET_DIR}" C-m
+
+tmux send-keys -t $SESSION:3 "monero-wallet-rpc \
+   --rpc-bind-ip 127.0.0.1 \
+   --rpc-bind-port ${BILL_WALLET_RPC_PORT} \
+   --wallet-dir ${BILL_WALLET_DIR} \
+   --disable-rpc-login \
+   --allow-mismatched-daemon-version; tmux wait-for -S billxmr" C-m
+
+sleep 2
+
+# Start the third wallet server - window 4
+echo "starting bill wallet server"
+
+tmux new-window -t $SESSION:4 -n 'charlie' $SHELL
+tmux send-keys -t $SESSION:4 "set +o history" C-m
+tmux send-keys -t $SESSION:4 "cd ${CHARLIE_WALLET_DIR}" C-m
+
+tmux send-keys -t $SESSION:4 "monero-wallet-rpc \
+   --rpc-bind-ip 127.0.0.1 \
+   --rpc-bind-port ${CHARLIE_WALLET_RPC_PORT} \
+   --wallet-dir ${CHARLIE_WALLET_DIR} \
+   --disable-rpc-login \
+   --allow-mismatched-daemon-version; tmux wait-for -S charliexmr" C-m
+
+sleep 2
+
+# Start the fourth wallet server - window 5
+echo "starting charlie_view wallet server"
+
+tmux new-window -t $SESSION:5 -n 'charlie_view' $SHELL
+tmux send-keys -t $SESSION:5 "set +o history" C-m
+tmux send-keys -t $SESSION:5 "cd ${CHARLIE_VIEW_WALLET_DIR}" C-m
+
+tmux send-keys -t $SESSION:5 "monero-wallet-rpc \
+   --rpc-bind-ip 127.0.0.1 \
+   --rpc-bind-port ${CHARLIE_VIEW_WALLET_RPC_PORT} \
+   --wallet-dir ${CHARLIE_VIEW_WALLET_DIR} \
+   --disable-rpc-login \
+   --allow-mismatched-daemon-version; tmux wait-for -S charlieviewxmr" C-m
+
+sleep 2
+
+# Start the fifth wallet server - window 5
+echo "starting Own wallet server"
+
+tmux new-window -t $SESSION:6 -n 'own' $SHELL
+tmux send-keys -t $SESSION:6 "set +o history" C-m
+tmux send-keys -t $SESSION:6 "cd ${OWN_WALLET_DIR}" C-m
+
+tmux send-keys -t $SESSION:6 "monero-wallet-rpc \
+   --rpc-bind-ip 127.0.0.1 \
+   --rpc-bind-port ${OWN_WALLET_RPC_PORT} \
+   --wallet-dir ${OWN_WALLET_DIR} \
+   --disable-rpc-login \
+   --allow-mismatched-daemon-version; tmux wait-for -S ownxmr" C-m
+
+sleep 2
+
+################################################################################
+# Create the wallets
+################################################################################
+
+# from here on we are working in the harness-ctl dir
+tmux send-keys -t $SESSION:0 "cd ${HARNESS_CTL_DIR}" C-m
+
+# recreate_fred wallet
+restore_deterministic_wallet ${FRED_WALLET_RPC_PORT} "${FRED_WALLET_NAME}" "${FRED_WALLET_PASS}" "${FRED_WALLET_SEED}"
+sleep 3
+
+# recreate bill wallet
+restore_deterministic_wallet ${BILL_WALLET_RPC_PORT} "${BILL_WALLET_NAME}" "${BILL_WALLET_PASS}" "${BILL_WALLET_SEED}"
+sleep 3
+
+# recreate charlie wallet
+restore_deterministic_wallet ${CHARLIE_WALLET_RPC_PORT} "${CHARLIE_WALLET_NAME}" "${CHARLIE_WALLET_PASS}" "${CHARLIE_WALLET_SEED}"
+sleep 3
+
+# ################################################################################
+# # Prepare the wallets
+# ################################################################################
+
+# mine 300 blocks to bill's wallet (60 confirmations needed for coinbase)
+generate ${BILL_WALLET_PRIMARY_ADDRESS} ${ALPHA_NODE_RPC_PORT} 60
+sleep 2
+generate ${BILL_WALLET_PRIMARY_ADDRESS} ${ALPHA_NODE_RPC_PORT} 60
+sleep 2
+generate ${BILL_WALLET_PRIMARY_ADDRESS} ${ALPHA_NODE_RPC_PORT} 60
+sleep 2
+generate ${BILL_WALLET_PRIMARY_ADDRESS} ${ALPHA_NODE_RPC_PORT} 60
+sleep 2
+generate ${BILL_WALLET_PRIMARY_ADDRESS} ${ALPHA_NODE_RPC_PORT} 60
+
+# let bill's wallet catch up - time sensitive: it is abnormal to mine 300 blocks so fast
+refresh_wallet ${BILL_WALLET_RPC_PORT} | jq '.'
+sleep 3
+
+# Monero block reward 0.6 XMR on regtest
+
+# bill starts with 180 XMR 144 spendable
+get_balance ${BILL_WALLET_RPC_PORT}
+
+# transfer some money from bill-the-miner to fred and charlie
+for money in 10000000000000 18000000000000 5000000000000 7000000000000 1000000000000 15000000000000 3000000000000 25000000000000
+do
+    transfer_simple ${BILL_WALLET_RPC_PORT} ${money} ${FRED_WALLET_PRIMARY_ADDRESS}
+	sleep 1
+	transfer_simple ${BILL_WALLET_RPC_PORT} ${money} ${CHARLIE_WALLET_PRIMARY_ADDRESS}
+	sleep 1
+    generate ${BILL_WALLET_PRIMARY_ADDRESS} ${ALPHA_NODE_RPC_PORT} 1
+    sleep 1
+done
+
+# generate charlie view only wallet (no spend key)
+generate_from_keys ${CHARLIE_VIEW_WALLET_RPC_PORT} \
+   "${CHARLIE_VIEW_WALLET_NAME}" \
+   "${CHARLIE_WALLET_PRIMARY_ADDRESS}" \
+   "" \
+   "${CHARLIE_WALLET_VIEWKEY}" \
+   "${CHARLIE_WALLET_PASS}"
+sleep 1
+
+refresh_wallet ${FRED_WALLET_RPC_PORT} | jq '.'
+sleep 1
+refresh_wallet ${BILL_WALLET_RPC_PORT} | jq '.'
+sleep 1
+refresh_wallet ${CHARLIE_WALLET_RPC_PORT} | jq '.'
+sleep 1
+refresh_wallet ${CHARLIE_VIEW_WALLET_RPC_PORT} | jq '.'
+sleep 1
+# mine 10 more blocks to make all fred's and charlie's money spendable (normal tx needs 10 confirmations)
+generate ${BILL_WALLET_PRIMARY_ADDRESS} ${ALPHA_NODE_RPC_PORT} 10
+# let all the wallets catch up
+sleep 3
+
+# Watch miner
+if [ -z "$NOMINER" ]
+then
+  tmux new-window -t $SESSION:7 -n "miner" $SHELL
+  tmux send-keys -t $SESSION:7 "cd ${NODES_ROOT}/harness-ctl" C-m
+  tmux send-keys -t $SESSION:7 "watch -n 15 ./mine-to-bill 1" C-m
+fi
+
+# Re-enable history and attach to the control session.
+tmux send-keys -t $SESSION:0 "set -o history" C-m
+tmux select-window -t $SESSION:0
+tmux attach-session -t $SESSION
diff --git a/dex/testing/xmr/image-1.png b/dex/testing/xmr/image-1.png
new file mode 100644
index 0000000000..ef61fcd40d
Binary files /dev/null and b/dex/testing/xmr/image-1.png differ
diff --git a/dex/testing/xmr/image-2.png b/dex/testing/xmr/image-2.png
new file mode 100644
index 0000000000..70e06a3734
Binary files /dev/null and b/dex/testing/xmr/image-2.png differ
diff --git a/dex/testing/xmr/monero_functions b/dex/testing/xmr/monero_functions
new file mode 100644
index 0000000000..2cca8f226e
--- /dev/null
+++ b/dex/testing/xmr/monero_functions
@@ -0,0 +1,390 @@
+#!/usr/bin/env bash
+
+# https://www.getmonero.org/resources/developer-guides/daemon-rpc.html#
+
+daemon-rpc-request() {    # older rpc style
+	local port="${1:?}"   # monerod port
+	local method="${2:?}" # RPC method name
+	local params="${3:?}" # JSON parameters to method
+	curl --http0.9 "http://localhost:${port}/${method}" \
+		-d "${params}" \
+		-H 'Content-Type: application/json'
+}
+
+# https://www.getmonero.org/resources/developer-guides/wallet-rpc.html
+
+monero-rpc-request() {    # newer json2 style
+	local port="${1:?}"   # monerod or monero-wallet-rpc port
+	local method="${2:?}" # RPC method name
+	local params="${3:?}" # JSON parameters to method
+	curl --http0.9 "http://localhost:${port}/json_rpc" \
+		--silent \
+		--show-error \
+		-d "{\"jsonrpc\":\"2.0\",\"id\":\"0\",\"method\":\"${method}\",\"params\":${params}}" \
+		-H 'Content-Type: application/json' \
+		-w "\n"
+}
+
+# Daemon
+
+# get info for a daemon including height, latest block hash, etc.
+get_info() {
+	local port="${1:?input a monero daemon port}"
+	params="{}"
+	monero-rpc-request ${port} "get_info" "${params}"
+}
+
+# mine into a mining (primary) address
+generate() {
+	local mine_addr="${1:?input a valid mine to (primary) address}"
+	local port="${2:?input a valid daemon rpc port}"
+	local num_blocks="${3:-1}"
+	params="{\"amount_of_blocks\":${num_blocks},\"wallet_address\":\"${mine_addr}\",\"starting_nonce\": 0}"
+	monero-rpc-request "${port}" "generateblocks" "${params}"
+}
+
+sendrawtransaction() {
+	local port="${1:?input a valid daemon rpc port}"
+	local tx_as_hex="${2:?input a valid tx hex string}"
+	local do_not_relay="${3:-false}" # do not relay to other nodes
+	params="{\"tx_as_hex\":\"${tx_as_hex}\",\"do_not_relay\":${do_not_relay}}"
+	daemon-rpc-request "${port}" "sendrawtransaction" "${params}"
+}
+
+get_transaction_pool() {
+	local port="${1:?input a valid daemon rpc port}"
+	params="{}"
+	daemon-rpc-request "${port}" "get_transaction_pool" "${params}"
+}
+
+get_transactions() {
+	local port="${1:?input a valid daemon rpc port}"
+	local txs_hashes="${2:?input one or more tx hashes as a string 1,2,..}"
+	local decode_as_json="${3:-false}"
+	local txs_hashes_json=""
+	IFS=',' read -ra TXID <<< "$txs_hashes"
+	for i in "${TXID[@]}"; do
+  		 txs_hashes_json+="\""
+  		 txs_hashes_json+="$i"
+  		 txs_hashes_json+="\","
+	done
+	txs_hashes_json=${txs_hashes_json%?} # will work in BASH 3.x
+	params="{\"txs_hashes\":[${txs_hashes_json}],\"decode_as_json\":${decode_as_json}}"
+	daemon-rpc-request "${port}" "get_transactions" "${params}"
+}
+
+# Wallets
+
+# recreate a wallet from seed
+restore_deterministic_wallet() {
+	local port="${1:?input a monero wallet port}"
+	local wallet_name="${2:?specify wallet name}"
+	local pass="${3:-""}" # default is no password ""
+	local seed="${4:?input seed 25 words from English wordlist}"
+	params="{\"filename\":\"${wallet_name}\",\"password\":\"${pass}\",\"seed\":\"${seed}\"}"
+	monero-rpc-request "${port}" "restore_deterministic_wallet" "${params}" | jq '.'
+}
+
+generate_from_keys() {
+	local port="${1:?input a monero wallet port}"
+	local wallet_name="${2:?specify wallet name}"
+	local address="${3:?specify wallet primary address}"
+	local spendkey="${4:-""}" # if no spendkey then a view only wallet will be created
+	local viewkey="${5:?specify wallet viewkey}"
+	local pass="${6:-""}" # default is no password ""
+	if [ "${spendkey}" != "" ]
+	then
+		params="{\"filename\":\"${wallet_name}\",\"address\":\"${address}\",\"spendkey\":\"${spendkey}\",\"viewkey\":\"${viewkey}\",\"password\":\"${pass}\"}"
+	else
+		params="{\"filename\":\"${wallet_name}\",\"address\":\"${address}\",\"viewkey\":\"${viewkey}\",\"password\":\"${pass}\"}"
+	fi
+	monero-rpc-request "${port}" "generate_from_keys" "${params}" | jq '.'
+}
+
+# create a new nettype mainnet wallet (on the fake regtest network chain)
+create_wallet() {
+	local port="${1:?input a monero wallet port}"
+	local wallet_name="${2:?specify wallet name}"
+	local pass="${3:-""}" # default is no password ""
+	params="{\"filename\":\"${wallet_name}\",\"password\":\"${pass}\",\"language\":\"English\"}"
+	monero-rpc-request "${port}" "create_wallet" "${params}" | jq '.'
+}
+
+# refresh wallet from daemon known transfers
+refresh_wallet() {
+	local port="${1:?input a monero wallet port}"
+	monero-rpc-request "${port}" "refresh" "{}"
+}
+
+# open a wallet that has a '--wallet_dir' known to wallet server in the dextest/monero/wallets tree
+open_wallet() {
+	local port="${1:?input a valid wallet rpc port}"
+	local filename="${2:?input a valid wallet filename such a fred, charlie, etc.}"
+	local password="${3:-""}" # password defaults to "" no password
+	params="{\"filename\":\"${filename}\",\"password\":\"${password}\"}"
+	monero-rpc-request ${port} "open_wallet" "${params}"
+}
+
+# save wallet and close; can reopen
+close_wallet() {
+	local port="${1:?input a valid wallet rpc port}"
+	params="{}"
+	monero-rpc-request ${port} "close_wallet" "${params}"
+}
+
+# save wallet and exit monero-wallet-rpc process
+stop_wallet() {
+	local port="${1:?input a valid wallet rpc port}"
+	params="{}"
+	monero-rpc-request ${port} "stop_wallet" "${params}"
+}
+
+# get the primary address of a wallet account 0 address index 0
+get_primary_address() {
+	local port="${1:?input a valid wallet rpc port}"
+	# account 0, address index 0
+	params="{\"account_index\":0,\"address_indices\":[0]}"
+	monero-rpc-request "${port}" "get_address" "${params}" | jq -r '.result.address'
+}
+
+# get simple balance from a wallet account - defaults to account 0
+get_balance() {
+	local port="${1:?input a valid wallet rpc port}"
+	local account="${2:-0}"
+	params="{\"account_index\":${account}}" # no sub-addresses
+	monero-rpc-request "${port}" "get_balance" "${params}"
+}
+
+incoming_transfers() {
+	local port="${1:?input a valid wallet rpc port}"
+	local transfer_type="${2:-all}"
+	# all, available (not yet spent) or unavailable (spent)
+	params="{\"transfer_type\":\"${transfer_type}\"}"
+	monero-rpc-request "${port}" "incoming_transfers" "${params}"
+}
+
+# get a key from a wallet - key_type is either "view_key" or "spend_key" or "mnemonic"
+query_key() {
+	local port="${1:?input a valid wallet rpc port}"
+	local key_type="${2,?input either view_key or mnemonic}"
+	params="{\"key_type\":\"${key_type}\"}"
+	monero-rpc-request "${port}" "query_key" "${params}"
+}
+
+# transfer monero to 1 recipient at their account 0, subaddress-indeces [0]
+transfer_simple() {
+	local port="${1:?input a valid wallet rpc port}"
+	local amount="${2:?input an amount of monero to send in atomic units 1e12}"
+	local address="${3:?input a valid destination wallet address}"
+	local unlock_time=${4:-0} # unlock after n blocks
+    other_params="\"account_index\":0,\"subaddr_indices\":[0],\"priority\":0,\"unlock_time\":${unlock_time},\"get_tx_key\":true,\"get_tx_hex\":true"
+	params="{\"destinations\":[{\"amount\":${amount},\"address\":\"${address}\"}], "${other_params}" }"
+	monero-rpc-request "${port}" "transfer" "${params}"
+}
+
+# Online Tx Creation & Offline Signing
+
+# export wallet outputs
+export_outputs() {
+	local port="${1:?input a valid wallet rpc port}"
+	params="{\"all\":true}"
+	monero-rpc-request "${port}" "export_outputs" "${params}" | jq '.'
+}
+
+# import outputs into a cold wallet only for offline signing process - unused
+import_outputs() {
+	local port="${1:?input a valid wallet rpc port for an offline cold wallet}"
+	local outputs_data_hex="${2:?input a valid outputs data hex string}"
+	params="{\"outputs_data_hex\":\"${outputs_data_hex}\"}"
+	monero-rpc-request "${port}" "import_outputs" "${params}"
+}
+
+export_key_images() {
+	local port="${1:?input a valid wallet rpc port}"
+	params="{\"all\":true}"
+	monero-rpc-request "${port}" "export_key_images" "${params}" | jq '.'
+}
+
+import_key_images() {
+	local port="${1:?input a valid wallet rpc port}"
+	local signed_key_images="${2:?input a a set valid  key images}" # json array of signed key images
+	params="{\"signed_key_images\":\"${signed_key_images}\"}"
+	monero-rpc-request "${port}" "import_key_images" "${params}"
+}
+
+# transfer monero to 1 recipient at their account 0, subaddress-indeces [0]
+# but do not send. If called from a normal wallet with keys it generates a
+# signed tx. Iff it is called for a view only wallet (like watch only) an
+# unsigned_txset (an unsigned tx) will be also returned. This can then be
+# signed by the parent full wallet proxy but offline (i.e. not connected to
+# alpha node) using the interactive monero-wallet-cli.
+#
+# Note: This is for online unsigned tx creation and offline signing also and can
+# also be used with a hardware wallet device like trezor. As a consequence not
+# only must the offline wallet have no connection to the monerod it can never
+# have had any connection to monerod or it is considered a Hot wallet and thus
+# is prevented from importing outputs by the monero code.
+# https://github.com/monero-project/monero/issues/9333
+#
+transfer_no_relay() {
+	local port="${1:?input a valid wallet rpc port (view-only wallet only to generate unsigned tx for cold signing Only}"
+	local amount="${2:?input an amount of monero to send in atomic units 1e12}"
+	local address="${3:?input a valid destination wallet address}"
+	local unlock_time=${4:-0} # unlock after n blocks
+	destinations="[{\"amount\":${amount},\"address\":\"${address}\"}]"
+    other_params="\"account_index\":0,\"subaddr_indices\":[0],\"priority\":0,\"unlock_time\":${unlock_time},\"do_not_relay\":true,\"get_tx_key\":true,\"get_tx_hex\":true,\"get_tx_metadata\":true"
+	params="{\"destinations\":[{\"amount\":${amount},\"address\":\"${address}\"}], "${other_params}" }"
+	monero-rpc-request "${port}" "transfer" "${params}"
+}
+
+# sign a prepared unsigned txset -- offline manual experimental
+#
+# Note: can only be done by an offline cold wallet that has never been "online"
+# use the monero-wallet-cli interactive tool instead in a manual process with
+# an unconnected charlie_view wallet which holds the inputs but not any spend keys.
+sign_transfer() {
+	local port="${1:?input a valid wallet rpc port for a cold wallet}"
+	local unsigned_txset="${2:?input an unsigned tx set}"
+	params="{\"unsigned_txset\":\"${unsigned_txset}\"}"
+	monero-rpc-request "${port}" "sign_transfer" "${params}"
+}
+
+cmd_help() {
+	echo "Commands Help:"
+	echo "--------------"
+	echo "alpha_get_transactions"
+	echo "- get transaction details for one or more txid"
+	echo "- inputs:"
+	echo "  - tx_hashes - hash1,hash2,hash3,..."
+	echo ""
+	echo "alpha_get_transactions_details"
+	echo "- get transaction development details from monerod including tx lock time"
+	echo "- inputs:"
+	echo "  - tx_hashes - hash1,hash2,hash3,..."
+	echo ""
+	echo "alpha_info"
+	echo "- get running daemon details - height, etc."
+	echo "- inputs: None"
+	echo ""
+	echo "alpha_sendrawtransaction"
+	echo "- broadcast a previously built signed tx"
+	echo "- inputs:"
+	echo "  - tx_as_hex string - can be generated with charlie_build_tx or fred_build_tx"
+	echo ""
+	echo "alpha_transaction_pool"
+	echo "- get mempool details"
+	echo "- inputs: None"
+	echo ""
+	echo "mine-to-bill"
+	echo "- generate 1 or more blocks to bill wallet"
+	echo "- inputs:"
+	echo "  - num_blocks - defaults to 1"
+	echo ""
+	echo "bill_balance"
+	echo "- get bill wallet balance details"
+	echo "- inputs: None"
+	echo ""
+	echo "bill_refresh_wallet"
+	echo "- update bill's wallet from the daemon latest info"
+	echo "- inputs: None"
+	echo ""
+	echo "bill_transfer_to"
+	echo "- build, sign and broadcast a transaction from bill wallet to another address"
+	echo "- inputs:"
+	echo "  - amount in in atomic units 1e12 - e.g. 1230000000000 = 1.23 XMR"
+	echo "  - address - recipient primary address - account index 0, subaddr_indeces [0]"
+	echo ""
+	echo "charlie_balance"
+	echo "- get charlie wallet balance details"
+	echo "- inputs: None"
+	echo ""
+	echo "charlie_refresh_wallet"
+	echo "- update charlie's wallet from the daemon latest info"
+	echo "- inputs: None"
+	echo ""
+	echo "charlie_build_tx"
+	echo "- build a signed tx for later broadcasting using alpha_sendrawtransaction"
+	echo "- inputs:"
+	echo "  - amount in in atomic units 1e12 - e.g. 1230000000000 = 1.23 XMR"
+	echo "  - address - recipient primary address - account index 0, subaddr_indeces [0]"
+	echo "  - unlock_time - unlock after n blocks and make spendable - defaults to 0 (no lock)"
+	echo "-outputs:"
+	echo "  - signed tx_blob"
+	echo "  - tx_hash"
+	echo ""
+	echo "charlie_incoming_transfers"
+	echo "- get a list of incoming mined transfers to charlie wallet"
+	echo "- inputs: None"
+	echo ""
+	echo "charlie_transfer_to"
+	echo "- build, sign and broadcast a transaction from charlie wallet to another address"
+	echo "- inputs"
+	echo "  - amount in in atomic units 1e12 - e.g. 1230000000000 = 1.23 XMR"
+	echo "  - address - recipient primary address - account index 0, subaddr_indeces [0]"
+	echo "  - unlock_time - unlock after n blocks and make spendable - defaults to 0 (no lock)"
+	echo ""
+	echo "fred_export_outputs"
+	echo "- export fred outputs hex"
+	echo "- input:"
+	echo "  - all - defaults to true - otherwise only new outputs since the last call"
+	echo ""
+	echo "charlie_export_outputs"
+	echo "- export charlie outputs hex"
+	echo "- input:"
+	echo "  - all - defaults to true - otherwise only new outputs since the last call"
+	echo ""
+	echo "charlie_view_export_outputs"
+	echo "- export charlie_view outputs hex - charlie_view knows the outputs but has no spend key"
+	echo "- inputs: None"
+	echo "- only useful in offline, cold signing process using monero-wallet-cli interactive tool"
+	echo "  must be hex decoded into a file to use in monero-wallet-cli"
+	echo ""
+	echo "fred_export_key_images"
+	echo "- export signed key images from fred wallet - an array of key images and ephemeral signatures"
+	echo "- input:"
+	echo "  - all - defaults to true - otherwise only new key images since the last call"
+	echo ""
+	echo "charlie_export_key_images"
+	echo "- export signed key images from charlie wallet - an array of key images and ephemeral signatures"
+	echo "- input:"
+	echo "  - all - defaults to true - otherwise only new key images since the last call"
+	echo ""
+	echo "fred_balance"
+	echo "- get fred wallet balance details"
+	echo "- inputs: None"
+	echo ""
+	echo "fred_build_tx"
+	echo "- build a signed tx for later broadcasting using alpha_sendrawtransaction"
+	echo "- inputs:"
+	echo "  - amount in in atomic units 1e12 - e.g. 1230000000000 = 1.23 XMR"
+	echo "  - address - recipient primary address - account index 0, subaddr_indeces [0]"
+	echo "  - unlock_time - unlock after n blocks and make spendable - defaults to 0 (no lock)"
+	echo "-outputs:"
+	echo "  - signed tx_blob"
+	echo "  - tx_hash"
+	echo ""
+	echo "fred_refresh_wallet"
+	echo "- update fred's wallet from the daemon latest info"
+	echo "- inputs: None"
+	echo ""
+	echo "fred_incoming_transfers"
+	echo "- get a list of incoming mined transfers to fred wallet"
+	echo "- inputs: None"
+	echo ""
+	echo "fred_transfer_to"
+	echo "- build, sign and broadcast a transaction from bill wallet to another address"
+	echo "- inputs"
+	echo "  - amount in in atomic units 1e12 - e.g. 1230000000000 = 1.23 XMR"
+	echo "  - address - recipient primary address - account index 0, subaddr_indeces [0]"
+	echo "  - unlock_time - unlock after n blocks and make spendable - defaults to 0 (no lock)"
+	echo ""
+	echo "wallets"
+	echo "- wallet details exported to the harness environment - useful for building commands in the harness window 0"
+	echo ""
+	echo "help"
+	echo "- this help"
+	echo ""
+	echo "quit"
+	echo "- shutdown daemons and the quit harness"
+	echo ""
+}
diff --git a/go.mod b/go.mod
index 5536b5c291..c4bab877fe 100644
--- a/go.mod
+++ b/go.mod
@@ -5,6 +5,7 @@ go 1.21
 require (
 	decred.org/dcrwallet/v4 v4.1.1
 	fyne.io/systray v1.10.1-0.20220621085403-9a2652634e93
+	github.com/agl/ed25519 v0.0.0-20170116200512-5312a6153412
 	github.com/btcsuite/btcd v0.24.2-beta.rc1.0.20240625142744-cc26860b4026
 	github.com/btcsuite/btcd/btcec/v2 v2.3.4
 	github.com/btcsuite/btcd/btcutil v1.1.5
@@ -43,6 +44,7 @@ require (
 	github.com/decred/go-socks v1.1.0
 	github.com/decred/slog v1.2.0
 	github.com/decred/vspd/types/v2 v2.1.0
+	github.com/dev-warrior777/go-monero v0.1.0
 	github.com/dgraph-io/badger v1.6.2
 	github.com/ethereum/go-ethereum v1.14.8
 	github.com/fatih/color v1.16.0
@@ -51,6 +53,7 @@ require (
 	github.com/gcash/bchutil v0.0.0-20210113190856-6ea28dff4000
 	github.com/go-chi/chi/v5 v5.0.1
 	github.com/gorilla/websocket v1.5.1
+	github.com/haven-protocol-org/monero-go-utils v0.0.0-20211126154105-058b2666f217
 	github.com/huandu/skiplist v1.2.0
 	github.com/jessevdk/go-flags v1.5.0
 	github.com/jrick/logrotate v1.0.0
@@ -81,7 +84,6 @@ require (
 	github.com/StackExchange/wmi v1.2.1 // indirect
 	github.com/VictoriaMetrics/fastcache v1.12.2 // indirect
 	github.com/aead/siphash v1.0.1 // indirect
-	github.com/agl/ed25519 v0.0.0-20170116200512-5312a6153412 // indirect
 	github.com/beorn7/perks v1.0.1 // indirect
 	github.com/bits-and-blooms/bitset v1.10.0 // indirect
 	github.com/btcsuite/btcwallet/wallet/txrules v1.2.1 // indirect
diff --git a/go.sum b/go.sum
index e532245662..084ee366e7 100644
--- a/go.sum
+++ b/go.sum
@@ -322,6 +322,8 @@ github.com/decred/vspd/types/v2 v2.1.0 h1:cUVlmHPeLVsksPRnr2WHsmC2t1Skl6g1WH0Hmp
 github.com/decred/vspd/types/v2 v2.1.0/go.mod h1:2xnNqedkt9GuL+pK8uIzDxqYxFlwLRflYFJH64b76n0=
 github.com/denis-tingajkin/go-header v0.4.2/go.mod h1:eLRHAVXzE5atsKAnNRDB90WHCFFnBUn4RN0nRcs1LJA=
 github.com/desertbit/timer v0.0.0-20180107155436-c41aec40b27f/go.mod h1:xH/i4TFMt8koVQZ6WFms69WAsDWr2XsYL3Hkl7jkoLE=
+github.com/dev-warrior777/go-monero v0.1.0 h1:86JJRiYNk2muLJFWM6kgb7qZh1gE/ETjvjHSW+3Rn5c=
+github.com/dev-warrior777/go-monero v0.1.0/go.mod h1:DSf/k695WklA8lTl1EzqNLhtKP3BE3x5KU6tsPrXp4k=
 github.com/dgraph-io/badger v1.6.2 h1:mNw0qs90GVgGGWylh0umH5iag1j6n/PeJtNvL6KY/x8=
 github.com/dgraph-io/badger v1.6.2/go.mod h1:JW2yswe3V058sS0kZ2h/AXeDSqFjxnZcRrVH//y2UQE=
 github.com/dgraph-io/ristretto v0.0.2 h1:a5WaUrDa0qm0YrAAS1tUykT5El3kt62KNZZeMxQn3po=
@@ -613,6 +615,8 @@ github.com/hashicorp/logutils v1.0.0/go.mod h1:QIAnNjmIWmVIIkWDTG1z5v++HQmx9WQRO
 github.com/hashicorp/mdns v1.0.0/go.mod h1:tL+uN++7HEJ6SQLQ2/p+z2pH24WQKWjBPkE0mNTz8vQ=
 github.com/hashicorp/memberlist v0.1.3/go.mod h1:ajVTdAv/9Im8oMAAj5G31PhhMCZJV2pPBoIllUwCN7I=
 github.com/hashicorp/serf v0.8.2/go.mod h1:6hOLApaqBFA1NXqRQAsxw9QxuDEvNxSQRwA/JwenrHc=
+github.com/haven-protocol-org/monero-go-utils v0.0.0-20211126154105-058b2666f217 h1:CflMOYZHhaBo+7up92oOYcesIG+qDCAKdJo+niKBFWM=
+github.com/haven-protocol-org/monero-go-utils v0.0.0-20211126154105-058b2666f217/go.mod h1:vSMDRpw62HGWO1Fi9DQwfgs4e3JCbt475GWY/W5DQZI=
 github.com/holiman/billy v0.0.0-20240216141850-2abb0c79d3c4 h1:X4egAf/gcS1zATw6wn4Ej8vjuVGxeHdan+bRb2ebyv4=
 github.com/holiman/billy v0.0.0-20240216141850-2abb0c79d3c4/go.mod h1:5GuXa7vkL8u9FkFuWdVvfR5ix8hRB7DbOAaYULamFpc=
 github.com/holiman/bloomfilter/v2 v2.0.3 h1:73e0e/V0tCydx14a0SCYS/EWCxgwLZ18CZcZKVu0fao=
diff --git a/internal/adaptorsigs/dcr/dcr.go b/internal/adaptorsigs/dcr/dcr.go
new file mode 100644
index 0000000000..2471034a75
--- /dev/null
+++ b/internal/adaptorsigs/dcr/dcr.go
@@ -0,0 +1,31 @@
+package dcr
+
+import "github.com/decred/dcrd/txscript/v4"
+
+func LockRefundTxScript(kal, kaf []byte, locktime int64) ([]byte, error) {
+	return txscript.NewScriptBuilder().
+		AddOp(txscript.OP_IF).
+		AddOp(txscript.OP_2).
+		AddData(kal).
+		AddData(kaf).
+		AddOp(txscript.OP_2).
+		AddOp(txscript.OP_CHECKMULTISIG).
+		AddOp(txscript.OP_ELSE).
+		AddInt64(locktime).
+		AddOp(txscript.OP_CHECKSEQUENCEVERIFY).
+		AddOp(txscript.OP_DROP).
+		AddData(kaf).
+		AddOp(txscript.OP_CHECKSIG).
+		AddOp(txscript.OP_ENDIF).
+		Script()
+}
+
+func LockTxScript(kal, kaf []byte) ([]byte, error) {
+	return txscript.NewScriptBuilder().
+		AddOp(txscript.OP_2).
+		AddData(kal).
+		AddData(kaf).
+		AddOp(txscript.OP_2).
+		AddOp(txscript.OP_CHECKMULTISIG).
+		Script()
+}
diff --git a/internal/cmd/xmrswap/main.go b/internal/cmd/xmrswap/main.go
new file mode 100644
index 0000000000..bbe538bbf4
--- /dev/null
+++ b/internal/cmd/xmrswap/main.go
@@ -0,0 +1,1221 @@
+//go:build libsecp256k1
+
+package main
+
+import (
+	"bytes"
+	"context"
+	"encoding/hex"
+	"errors"
+	"fmt"
+	"math"
+	"math/big"
+	"net/http"
+	"os"
+	"path/filepath"
+	"time"
+
+	"decred.org/dcrdex/dex"
+	"decred.org/dcrdex/dex/config"
+	dcradaptor "decred.org/dcrdex/internal/adaptorsigs/dcr"
+	"decred.org/dcrdex/internal/libsecp256k1"
+	"decred.org/dcrwallet/v4/rpc/client/dcrwallet"
+	dcrwalletjson "decred.org/dcrwallet/v4/rpc/jsonrpc/types"
+	"github.com/agl/ed25519/edwards25519"
+	"github.com/decred/dcrd/chaincfg/chainhash"
+	"github.com/decred/dcrd/chaincfg/v3"
+	"github.com/decred/dcrd/dcrec"
+	"github.com/decred/dcrd/dcrec/edwards/v2"
+	"github.com/decred/dcrd/dcrec/secp256k1/v4"
+	"github.com/decred/dcrd/rpcclient/v8"
+	"github.com/decred/dcrd/txscript/v4"
+	"github.com/decred/dcrd/txscript/v4/sign"
+	"github.com/decred/dcrd/txscript/v4/stdaddr"
+	"github.com/decred/dcrd/wire"
+	"github.com/decred/slog"
+	"github.com/dev-warrior777/go-monero/rpc"
+	"github.com/fatih/color"
+	"github.com/haven-protocol-org/monero-go-utils/base58"
+)
+
+// TODO: Verification at all stages has not been implemented yet.
+
+// fieldIntSize is the size of a field element encoded
+// as bytes.
+const (
+	fieldIntSize = 32
+	dcrAmt       = 7_000_000 // atoms
+	xmrAmt       = 1_000     // 1e12 units
+	dumbFee      = int64(6000)
+)
+
+var (
+	homeDir    = os.Getenv("HOME")
+	dextestDir = filepath.Join(homeDir, "dextest")
+	bobDir     = filepath.Join(dextestDir, "xmr", "wallets", "bob")
+	curve      = edwards.Edwards()
+)
+
+func main() {
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+	if err := run(ctx); err != nil {
+		fmt.Fprintf(os.Stderr, "%v\n", err)
+	}
+}
+
+type walletClient = dcrwallet.Client
+
+type combinedClient struct {
+	*rpcclient.Client
+	*walletClient
+	chainParams *chaincfg.Params
+}
+
+func newCombinedClient(nodeRPCClient *rpcclient.Client, chainParams *chaincfg.Params) *combinedClient {
+	return &combinedClient{
+		nodeRPCClient,
+		dcrwallet.NewClient(dcrwallet.RawRequestCaller(nodeRPCClient), chainParams),
+		chainParams,
+	}
+}
+
+type client struct {
+	xmr *rpc.Client
+	dcr *combinedClient
+
+	kbvf, kbsf, kbvl, kbsl, vkbv *edwards.PrivateKey
+	pkbsf, pkbs                  *edwards.PublicKey
+	kaf, kal                     *secp256k1.PrivateKey
+	pkal, pkaf, pkasl, pkbsl     *secp256k1.PublicKey
+	kbsfDleag, kbslDleag         [libsecp256k1.ProofLen]byte
+	lockTxEsig                   [libsecp256k1.CTLen]byte
+	lockTx                       *wire.MsgTx
+	vIn                          int
+}
+
+func newRPCWallet(settings map[string]string, logger dex.Logger, net dex.Network) (*combinedClient, error) {
+	certs, err := os.ReadFile(settings["rpccert"])
+	if err != nil {
+		return nil, fmt.Errorf("TLS certificate read error: %w", err)
+	}
+
+	cfg := &rpcclient.ConnConfig{
+		Host:                settings["rpclisten"],
+		Endpoint:            "ws",
+		User:                settings["rpcuser"],
+		Pass:                settings["rpcpass"],
+		Certificates:        certs,
+		DisableConnectOnNew: true, // don't start until Connect
+	}
+	if cfg.User == "" {
+		cfg.User = "user"
+	}
+	if cfg.Pass == "" {
+		cfg.Pass = "pass"
+	}
+
+	nodeRPCClient, err := rpcclient.New(cfg, nil)
+	if err != nil {
+		return nil, fmt.Errorf("error setting up rpc client: %w", err)
+	}
+
+	var params *chaincfg.Params
+	switch net {
+	case dex.Simnet:
+		params = chaincfg.SimNetParams()
+	case dex.Testnet:
+		params = chaincfg.TestNet3Params()
+	case dex.Mainnet:
+		params = chaincfg.MainNetParams()
+	default:
+		return nil, fmt.Errorf("unknown network ID: %d", uint8(net))
+	}
+
+	return newCombinedClient(nodeRPCClient, params), nil
+}
+
+func newClient(ctx context.Context, xmrAddr, dcrNode string) (*client, error) {
+	xmr := rpc.New(rpc.Config{
+		Address: xmrAddr,
+		Client:  &http.Client{},
+	})
+
+	settings, err := config.Parse(filepath.Join(dextestDir, "dcr", dcrNode, fmt.Sprintf("%s.conf", dcrNode)))
+	if err != nil {
+		return nil, err
+	}
+	settings["account"] = "default"
+
+	dcr, err := newRPCWallet(settings, dex.StdOutLogger(dcrNode, slog.LevelTrace), dex.Simnet)
+	if err != nil {
+		return nil, err
+	}
+
+	err = dcr.Connect(ctx, false)
+	if err != nil {
+		return nil, err
+	}
+
+	return &client{
+		xmr: xmr,
+		dcr: dcr,
+	}, nil
+}
+
+// reverse reverses a byte string.
+func reverse(s *[32]byte) {
+	for i, j := 0, len(s)-1; i < j; i, j = i+1, j-1 {
+		s[i], s[j] = s[j], s[i]
+	}
+}
+
+// bigIntToEncodedBytes converts a big integer into its corresponding
+// 32 byte little endian representation.
+func bigIntToEncodedBytes(a *big.Int) *[32]byte {
+	s := new([32]byte)
+	if a == nil {
+		return s
+	}
+	// Caveat: a can be longer than 32 bytes.
+	aB := a.Bytes()
+
+	// If we have a short byte string, expand
+	// it so that it's long enough.
+	aBLen := len(aB)
+	if aBLen < fieldIntSize {
+		diff := fieldIntSize - aBLen
+		for i := 0; i < diff; i++ {
+			aB = append([]byte{0x00}, aB...)
+		}
+	}
+
+	for i := 0; i < fieldIntSize; i++ {
+		s[i] = aB[i]
+	}
+
+	// Reverse the byte string --> little endian after
+	// encoding.
+	reverse(s)
+
+	return s
+}
+
+// encodedBytesToBigInt converts a 32 byte little endian representation of
+// an integer into a big, big endian integer.
+func encodedBytesToBigInt(s *[32]byte) *big.Int {
+	// Use a copy so we don't screw up our original
+	// memory.
+	sCopy := new([32]byte)
+	for i := 0; i < fieldIntSize; i++ {
+		sCopy[i] = s[i]
+	}
+	reverse(sCopy)
+
+	bi := new(big.Int).SetBytes(sCopy[:])
+
+	return bi
+}
+
+// scalarAdd adds two scalars.
+func scalarAdd(a, b *big.Int) *big.Int {
+	feA := bigIntToFieldElement(a)
+	feB := bigIntToFieldElement(b)
+	sum := new(edwards25519.FieldElement)
+
+	edwards25519.FeAdd(sum, feA, feB)
+	sumArray := new([32]byte)
+	edwards25519.FeToBytes(sumArray, sum)
+
+	return encodedBytesToBigInt(sumArray)
+}
+
+// bigIntToFieldElement converts a big little endian integer into its corresponding
+// 40 byte field representation.
+func bigIntToFieldElement(a *big.Int) *edwards25519.FieldElement {
+	aB := bigIntToEncodedBytes(a)
+	fe := new(edwards25519.FieldElement)
+	edwards25519.FeFromBytes(fe, aB)
+	return fe
+}
+
+func sumPubKeys(pubA, pubB *edwards.PublicKey) *edwards.PublicKey {
+	pkSumX, pkSumY := curve.Add(pubA.GetX(), pubA.GetY(), pubB.GetX(), pubB.GetY())
+	return edwards.NewPublicKey(pkSumX, pkSumY)
+}
+
+// Convert the DCR value to atoms.
+func toAtoms(v float64) uint64 {
+	return uint64(math.Round(v * 1e8))
+}
+
+// createNewXMRWallet uses the "own" wallet to create a new xmr wallet from keys
+// and open it. Can only create one wallet at a time.
+func createNewXMRWallet(ctx context.Context, genReq rpc.GenerateFromKeysRequest) (*rpc.Client, error) {
+	xmrChecker := rpc.New(rpc.Config{
+		Address: "http://127.0.0.1:28484/json_rpc",
+		Client:  &http.Client{},
+	})
+
+	_, err := xmrChecker.GenerateFromKeys(ctx, &genReq)
+	if err != nil {
+		return nil, fmt.Errorf("unable to generate wallet: %v", err)
+	}
+
+	openReq := rpc.OpenWalletRequest{
+		Filename: genReq.Filename,
+	}
+
+	err = xmrChecker.OpenWallet(ctx, &openReq)
+	if err != nil {
+		return nil, err
+	}
+	return xmrChecker, nil
+}
+
+type prettyLogger struct {
+	c *color.Color
+}
+
+func (cl prettyLogger) Write(p []byte) (n int, err error) {
+	return cl.c.Fprint(os.Stdout, string(p))
+}
+
+func run(ctx context.Context) error {
+	pl := prettyLogger{c: color.New(color.FgGreen)}
+	log := dex.NewLogger("T", dex.LevelInfo, pl)
+
+	log.Info("Running success.")
+	if err := success(ctx); err != nil {
+		return err
+	}
+	log.Info("Success completed without error.")
+	log.Info("------------------")
+	log.Info("Running alice bails before xmr init.")
+	if err := aliceBailsBeforeXmrInit(ctx); err != nil {
+		return err
+	}
+	log.Info("Alice bails before xmr init completed without error.")
+	log.Info("------------------")
+	log.Info("Running refund.")
+	if err := refund(ctx); err != nil {
+		return err
+	}
+	log.Info("Refund completed without error.")
+	log.Info("------------------")
+	log.Info("Running bob bails after xmr init.")
+	if err := bobBailsAfterXmrInit(ctx); err != nil {
+		return err
+	}
+	log.Info("Bob bails after xmr init completed without error.")
+	return nil
+}
+
+// generateDleag starts the trade by creating some keys.
+func (c *client) generateDleag(ctx context.Context) (pkbsf *edwards.PublicKey, kbvf *edwards.PrivateKey,
+	pkaf *secp256k1.PublicKey, dleag [libsecp256k1.ProofLen]byte, err error) {
+	fail := func(err error) (*edwards.PublicKey, *edwards.PrivateKey,
+		*secp256k1.PublicKey, [libsecp256k1.ProofLen]byte, error) {
+		return nil, nil, nil, [libsecp256k1.ProofLen]byte{}, err
+	}
+	// This private key is shared with bob and becomes half of the view key.
+	c.kbvf, err = edwards.GeneratePrivateKey()
+	if err != nil {
+		return fail(err)
+	}
+
+	// Not shared. Becomes half the spend key. The pubkey is shared.
+	c.kbsf, err = edwards.GeneratePrivateKey()
+	if err != nil {
+		return fail(err)
+	}
+	c.pkbsf = c.kbsf.PubKey()
+
+	// Not shared. This is used for all dcr signatures. Using a wallet
+	// address because funds may go here in the case of success. Any address
+	// would work for the spendTx though.
+	kafAddr, err := c.dcr.GetNewAddress(ctx, "default")
+	if err != nil {
+		return fail(err)
+	}
+	kafWIF, err := c.dcr.DumpPrivKey(ctx, kafAddr)
+	if err != nil {
+		return fail(err)
+	}
+	c.kaf = secp256k1.PrivKeyFromBytes(kafWIF.PrivKey())
+
+	// Share this pubkey with the other party.
+	c.pkaf = c.kaf.PubKey()
+
+	c.kbsfDleag, err = libsecp256k1.Ed25519DleagProve(c.kbsf)
+	if err != nil {
+		return fail(err)
+	}
+
+	c.pkasl, err = secp256k1.ParsePubKey(c.kbsfDleag[:33])
+	if err != nil {
+		return fail(err)
+	}
+
+	return c.pkbsf, c.kbvf, c.pkaf, c.kbsfDleag, nil
+}
+
+// generateLockTxn creates even more keys and some transactions.
+func (c *client) generateLockTxn(ctx context.Context, pkbsf *edwards.PublicKey,
+	kbvf *edwards.PrivateKey, pkaf *secp256k1.PublicKey, kbsfDleag [libsecp256k1.ProofLen]byte) (refundSig,
+	lockRefundTxScript, lockTxScript []byte, refundTx, spendRefundTx *wire.MsgTx, lockTxVout int,
+	pkbs *edwards.PublicKey, vkbv *edwards.PrivateKey, dleag [libsecp256k1.ProofLen]byte, err error) {
+	fail := func(err error) ([]byte, []byte, []byte, *wire.MsgTx, *wire.MsgTx, int, *edwards.PublicKey, *edwards.PrivateKey, [libsecp256k1.ProofLen]byte, error) {
+		return nil, nil, nil, nil, nil, 0, nil, nil, [libsecp256k1.ProofLen]byte{}, err
+	}
+	c.kbsfDleag = kbsfDleag
+	c.pkasl, err = secp256k1.ParsePubKey(c.kbsfDleag[:33])
+	if err != nil {
+		return fail(err)
+	}
+	c.kbvf = kbvf
+	c.pkbsf = pkbsf
+	c.pkaf = pkaf
+
+	// This becomes the other half of the view key.
+	c.kbvl, err = edwards.GeneratePrivateKey()
+	if err != nil {
+		return fail(err)
+	}
+
+	// This becomes the other half of the spend key and is shared.
+	c.kbsl, err = edwards.GeneratePrivateKey()
+	if err != nil {
+		return fail(err)
+	}
+
+	// This kept private. This is used for all dcr signatures.
+	c.kal, err = secp256k1.GeneratePrivateKey()
+	if err != nil {
+		return fail(err)
+	}
+
+	pkal := c.kal.PubKey()
+
+	// This is the full xmr view key and is shared. Alice can also calculate
+	// it using kbvl.
+	vkbvBig := scalarAdd(c.kbvf.GetD(), c.kbvl.GetD())
+	vkbvBig.Mod(vkbvBig, curve.N)
+	var vkbvBytes [32]byte
+	vkbvBig.FillBytes(vkbvBytes[:])
+	c.vkbv, _, err = edwards.PrivKeyFromScalar(vkbvBytes[:])
+	if err != nil {
+		return fail(fmt.Errorf("unable to create vkbv: %v", err))
+	}
+
+	// The public key for the xmr spend key. No party knows the full private
+	// key yet.
+	c.pkbs = sumPubKeys(c.kbsl.PubKey(), c.pkbsf)
+
+	// The lock tx is the initial dcr transaction.
+	lockTxScript, err = dcradaptor.LockTxScript(pkal.SerializeCompressed(), c.pkaf.SerializeCompressed())
+	if err != nil {
+		return fail(err)
+	}
+
+	scriptAddr, err := stdaddr.NewAddressScriptHashV0(lockTxScript, c.dcr.chainParams)
+	if err != nil {
+		return fail(fmt.Errorf("error encoding script address: %w", err))
+	}
+	p2shLockScriptVer, p2shLockScript := scriptAddr.PaymentScript()
+	// Add the transaction output.
+	txOut := &wire.TxOut{
+		Value:    dcrAmt,
+		Version:  p2shLockScriptVer,
+		PkScript: p2shLockScript,
+	}
+	unfundedLockTx := wire.NewMsgTx()
+	unfundedLockTx.AddTxOut(txOut)
+	txBytes, err := unfundedLockTx.Bytes()
+	if err != nil {
+		return fail(err)
+	}
+
+	fundRes, err := c.dcr.FundRawTransaction(ctx, hex.EncodeToString(txBytes), "default", dcrwalletjson.FundRawTransactionOptions{})
+	if err != nil {
+		return fail(err)
+	}
+
+	txBytes, err = hex.DecodeString(fundRes.Hex)
+	if err != nil {
+		return fail(err)
+	}
+
+	c.lockTx = wire.NewMsgTx()
+	if err = c.lockTx.FromBytes(txBytes); err != nil {
+		return fail(err)
+	}
+	for i, out := range c.lockTx.TxOut {
+		if bytes.Equal(out.PkScript, p2shLockScript) {
+			c.vIn = i
+			break
+		}
+	}
+
+	durationLocktime := int64(2) // blocks
+	// Unable to use time for tests as this is multiples of 512 seconds.
+	// durationLocktime := int64(10) // seconds * 512
+	// durationLocktime |= wire.SequenceLockTimeIsSeconds
+
+	// The refund tx does not outright refund but moves funds to the refund
+	// script's address. This is signed by both parties before the initial tx.
+	lockRefundTxScript, err = dcradaptor.LockRefundTxScript(pkal.SerializeCompressed(), c.pkaf.SerializeCompressed(), durationLocktime)
+	if err != nil {
+		return fail(err)
+	}
+
+	scriptAddr, err = stdaddr.NewAddressScriptHashV0(lockRefundTxScript, c.dcr.chainParams)
+	if err != nil {
+		return fail(fmt.Errorf("error encoding script address: %w", err))
+	}
+	p2shScriptVer, p2shScript := scriptAddr.PaymentScript()
+	txOut = &wire.TxOut{
+		Value:    dcrAmt - dumbFee,
+		Version:  p2shScriptVer,
+		PkScript: p2shScript,
+	}
+	refundTx = wire.NewMsgTx()
+	refundTx.AddTxOut(txOut)
+	h := c.lockTx.TxHash()
+	op := wire.NewOutPoint(&h, uint32(c.vIn), 0)
+	txIn := wire.NewTxIn(op, dcrAmt, nil)
+	refundTx.AddTxIn(txIn)
+
+	// This sig must be shared with Alice.
+	refundSig, err = sign.RawTxInSignature(refundTx, c.vIn, lockTxScript, txscript.SigHashAll, c.kal.Serialize(), dcrec.STEcdsaSecp256k1)
+	if err != nil {
+		return fail(err)
+	}
+
+	// SpendRefundTx is used in the final refund. Alice can sign it after a
+	// time and send wherever. Bob must use a signature that will reveal his
+	// half of the xmr key.
+	newAddr, err := c.dcr.GetNewAddress(ctx, "default")
+	if err != nil {
+		return fail(err)
+	}
+	p2AddrScriptVer, p2AddrScript := newAddr.PaymentScript()
+	txOut = &wire.TxOut{
+		Value:    dcrAmt - dumbFee - dumbFee,
+		Version:  p2AddrScriptVer,
+		PkScript: p2AddrScript,
+	}
+	spendRefundTx = wire.NewMsgTx()
+	spendRefundTx.AddTxOut(txOut)
+	h = refundTx.TxHash()
+	op = wire.NewOutPoint(&h, 0, 0)
+	txIn = wire.NewTxIn(op, dcrAmt, nil)
+	txIn.Sequence = uint32(durationLocktime)
+	spendRefundTx.AddTxIn(txIn)
+	spendRefundTx.Version = wire.TxVersionTreasury
+
+	c.kbslDleag, err = libsecp256k1.Ed25519DleagProve(c.kbsl)
+	if err != nil {
+		return fail(err)
+	}
+	c.pkbsl, err = secp256k1.ParsePubKey(c.kbslDleag[:33])
+	if err != nil {
+		return fail(err)
+	}
+
+	return refundSig, lockRefundTxScript, lockTxScript, refundTx, spendRefundTx, c.vIn, c.pkbs, c.vkbv, c.kbslDleag, nil
+}
+
+// generateRefundSigs signs the refund tx and shares the spendRefund esig that
+// allows bob to spend the refund tx.
+func (c *client) generateRefundSigs(refundTx, spendRefundTx *wire.MsgTx, vIn int, lockTxScript, lockRefundTxScript []byte, dleag [libsecp256k1.ProofLen]byte) (esig [libsecp256k1.CTLen]byte, refundSig []byte, err error) {
+	fail := func(err error) ([libsecp256k1.CTLen]byte, []byte, error) {
+		return [libsecp256k1.CTLen]byte{}, nil, err
+	}
+	c.kbslDleag = dleag
+	c.vIn = vIn
+	c.pkbsl, err = secp256k1.ParsePubKey(c.kbslDleag[:33])
+	if err != nil {
+		return fail(err)
+	}
+
+	hash, err := txscript.CalcSignatureHash(lockRefundTxScript, txscript.SigHashAll, spendRefundTx, 0, nil)
+	if err != nil {
+		return fail(err)
+	}
+
+	var h chainhash.Hash
+	copy(h[:], hash)
+	esig, err = libsecp256k1.EcdsaotvesEncSign(c.kaf, c.pkbsl, h)
+	if err != nil {
+		return fail(err)
+	}
+
+	// Share with bob.
+	refundSig, err = sign.RawTxInSignature(refundTx, c.vIn, lockTxScript, txscript.SigHashAll, c.kaf.Serialize(), dcrec.STEcdsaSecp256k1)
+	if err != nil {
+		return fail(err)
+	}
+
+	return esig, refundSig, nil
+}
+
+// initDcr is the first transaction to happen and creates a dcr transaction.
+func (c *client) initDcr(ctx context.Context) (spendTx *wire.MsgTx, err error) {
+	fail := func(err error) (*wire.MsgTx, error) {
+		return nil, err
+	}
+	pkaslAddr, err := stdaddr.NewAddressPubKeyHashEcdsaSecp256k1(0, stdaddr.Hash160(c.pkaf.SerializeCompressed()), c.dcr.chainParams)
+	if err != nil {
+		return fail(err)
+	}
+	p2AddrScriptVer, p2AddrScript := pkaslAddr.PaymentScript()
+
+	txOut := &wire.TxOut{
+		Value:    dcrAmt - dumbFee,
+		Version:  p2AddrScriptVer,
+		PkScript: p2AddrScript,
+	}
+	spendTx = wire.NewMsgTx()
+	spendTx.AddTxOut(txOut)
+	h := c.lockTx.TxHash()
+	op := wire.NewOutPoint(&h, uint32(c.vIn), 0)
+	txIn := wire.NewTxIn(op, dcrAmt, nil)
+	spendTx.AddTxIn(txIn)
+
+	tx, complete, err := c.dcr.SignRawTransaction(ctx, c.lockTx)
+	if err != nil {
+		return fail(err)
+	}
+	if !complete {
+		return fail(errors.New("lock tx sign not complete"))
+	}
+
+	_, err = c.dcr.SendRawTransaction(ctx, tx, false)
+	if err != nil {
+		return fail(fmt.Errorf("unable to send lock tx: %v", err))
+	}
+	return spendTx, nil
+}
+
+// initXmr sends an xmr transaciton. Alice can only do this after confirming the
+// dcr transaction.
+func (c *client) initXmr(ctx context.Context, vkbv *edwards.PrivateKey, pkbs *edwards.PublicKey) error {
+	c.vkbv = vkbv
+	c.pkbs = pkbs
+	var fullPubKey []byte
+	fullPubKey = append(fullPubKey, c.pkbs.SerializeCompressed()...)
+	fullPubKey = append(fullPubKey, c.vkbv.PubKey().SerializeCompressed()...)
+
+	sharedAddr := base58.EncodeAddr(18, fullPubKey)
+
+	dest := rpc.Destination{
+		Amount:  xmrAmt,
+		Address: string(sharedAddr),
+	}
+	sendReq := rpc.TransferRequest{
+		Destinations: []rpc.Destination{dest},
+	}
+
+	sendRes, err := c.xmr.Transfer(ctx, &sendReq)
+	if err != nil {
+		return err
+	}
+	fmt.Printf("xmr sent\n%+v\n", *sendRes)
+	return nil
+}
+
+// sendLockTxSig allows Alice to redeem the dcr. If bob does not send this alice
+// can eventually take his btc. Otherwise bob refunding will reveal his half of
+// the xmr spend key allowing Alice to refund.
+func (c *client) sendLockTxSig(lockTxScript []byte, spendTx *wire.MsgTx) (esig [libsecp256k1.CTLen]byte, err error) {
+	hash, err := txscript.CalcSignatureHash(lockTxScript, txscript.SigHashAll, spendTx, 0, nil)
+	if err != nil {
+		return [libsecp256k1.CTLen]byte{}, err
+	}
+
+	var h chainhash.Hash
+	copy(h[:], hash)
+
+	esig, err = libsecp256k1.EcdsaotvesEncSign(c.kal, c.pkasl, h)
+	if err != nil {
+		return [libsecp256k1.CTLen]byte{}, err
+	}
+	c.lockTxEsig = esig
+	return esig, nil
+}
+
+// redeemDcr redeems the dcr, revealing a signature that reveals half of the xmr
+// spend key.
+func (c *client) redeemDcr(ctx context.Context, esig [libsecp256k1.CTLen]byte, lockTxScript []byte, spendTx *wire.MsgTx) (kalSig []byte, err error) {
+	kasl := secp256k1.PrivKeyFromBytes(c.kbsf.Serialize())
+	kalSig, err = libsecp256k1.EcdsaotvesDecSig(kasl, esig)
+	if err != nil {
+		return nil, err
+	}
+	kalSig = append(kalSig, byte(txscript.SigHashAll))
+
+	kafSig, err := sign.RawTxInSignature(spendTx, 0, lockTxScript, txscript.SigHashAll, c.kaf.Serialize(), dcrec.STEcdsaSecp256k1)
+	if err != nil {
+		return nil, err
+	}
+
+	spendSig, err := txscript.NewScriptBuilder().
+		AddData(kalSig).
+		AddData(kafSig).
+		AddData(lockTxScript).
+		Script()
+
+	spendTx.TxIn[0].SignatureScript = spendSig
+
+	tx, err := c.dcr.SendRawTransaction(ctx, spendTx, false)
+	if err != nil {
+		return nil, err
+	}
+	fmt.Println(tx)
+
+	return kalSig, nil
+}
+
+// redeemXmr redeems xmr by creating a new xmr wallet with the complete spend
+// and view private keys.
+func (c *client) redeemXmr(ctx context.Context, kalSig []byte) (*rpc.Client, error) {
+	kaslRecovered, err := libsecp256k1.EcdsaotvesRecEncKey(c.pkasl, c.lockTxEsig, kalSig[:len(kalSig)-1])
+	if err != nil {
+		return nil, err
+	}
+
+	kbsfRecovered, _, err := edwards.PrivKeyFromScalar(kaslRecovered.Serialize())
+	if err != nil {
+		return nil, fmt.Errorf("unable to recover kbsf: %v", err)
+	}
+	vkbsBig := scalarAdd(c.kbsl.GetD(), kbsfRecovered.GetD())
+	vkbsBig.Mod(vkbsBig, curve.N)
+	var vkbsBytes [32]byte
+	vkbsBig.FillBytes(vkbsBytes[:])
+	vkbs, _, err := edwards.PrivKeyFromScalar(vkbsBytes[:])
+	if err != nil {
+		return nil, fmt.Errorf("unable to create vkbs: %v", err)
+	}
+
+	var fullPubKey []byte
+	fullPubKey = append(fullPubKey, vkbs.PubKey().Serialize()...)
+	fullPubKey = append(fullPubKey, c.vkbv.PubKey().Serialize()...)
+	walletAddr := base58.EncodeAddr(18, fullPubKey)
+	walletFileName := fmt.Sprintf("%s_spend", walletAddr)
+
+	var vkbvBytes [32]byte
+	copy(vkbvBytes[:], c.vkbv.Serialize())
+
+	reverse(&vkbsBytes)
+	reverse(&vkbvBytes)
+
+	genReq := rpc.GenerateFromKeysRequest{
+		Filename: walletFileName,
+		Address:  walletAddr,
+		SpendKey: hex.EncodeToString(vkbsBytes[:]),
+		ViewKey:  hex.EncodeToString(vkbvBytes[:]),
+	}
+
+	xmrChecker, err := createNewXMRWallet(ctx, genReq)
+	if err != nil {
+		return nil, err
+	}
+
+	return xmrChecker, nil
+}
+
+// startRefund starts the refund and can be done by either party.
+func (c *client) startRefund(ctx context.Context, kalSig, kafSig, lockTxScript []byte, refundTx *wire.MsgTx) error {
+	refundSig, err := txscript.NewScriptBuilder().
+		AddData(kalSig).
+		AddData(kafSig).
+		AddData(lockTxScript).
+		Script()
+
+	refundTx.TxIn[0].SignatureScript = refundSig
+
+	_, err = c.dcr.SendRawTransaction(ctx, refundTx, false)
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// refundDcr returns dcr to bob while revealing his half of the xmr spend key.
+func (c *client) refundDcr(ctx context.Context, spendRefundTx *wire.MsgTx, esig [libsecp256k1.CTLen]byte, lockRefundTxScript []byte) (kafSig []byte, err error) {
+	kasf := secp256k1.PrivKeyFromBytes(c.kbsl.Serialize())
+	kafSig, err = libsecp256k1.EcdsaotvesDecSig(kasf, esig)
+	if err != nil {
+		return nil, err
+	}
+	kafSig = append(kafSig, byte(txscript.SigHashAll))
+
+	kalSig, err := sign.RawTxInSignature(spendRefundTx, 0, lockRefundTxScript, txscript.SigHashAll, c.kal.Serialize(), dcrec.STEcdsaSecp256k1)
+	if err != nil {
+		return nil, err
+	}
+	refundSig, err := txscript.NewScriptBuilder().
+		AddData(kalSig).
+		AddData(kafSig).
+		AddOp(txscript.OP_TRUE).
+		AddData(lockRefundTxScript).
+		Script()
+
+	spendRefundTx.TxIn[0].SignatureScript = refundSig
+
+	_, err = c.dcr.SendRawTransaction(ctx, spendRefundTx, false)
+	if err != nil {
+		return nil, err
+	}
+	// TODO: Confirm refund happened.
+	return kafSig, nil
+}
+
+// refundXmr refunds xmr but cannot happen without the dcr refund happening first.
+func (c *client) refundXmr(ctx context.Context, kafSig []byte, esig [libsecp256k1.CTLen]byte) (*rpc.Client, error) {
+	kbslRecovered, err := libsecp256k1.EcdsaotvesRecEncKey(c.pkbsl, esig, kafSig[:len(kafSig)-1])
+	if err != nil {
+		return nil, err
+	}
+
+	kaslRecovered, _, err := edwards.PrivKeyFromScalar(kbslRecovered.Serialize())
+	if err != nil {
+		return nil, fmt.Errorf("unable to recover kasl: %v", err)
+	}
+	vkbsBig := scalarAdd(c.kbsf.GetD(), kaslRecovered.GetD())
+	vkbsBig.Mod(vkbsBig, curve.N)
+	var vkbsBytes [32]byte
+	vkbsBig.FillBytes(vkbsBytes[:])
+	vkbs, _, err := edwards.PrivKeyFromScalar(vkbsBytes[:])
+	if err != nil {
+		return nil, fmt.Errorf("unable to create vkbs: %v", err)
+	}
+
+	var fullPubKey []byte
+	fullPubKey = append(fullPubKey, vkbs.PubKey().Serialize()...)
+	fullPubKey = append(fullPubKey, c.vkbv.PubKey().Serialize()...)
+	walletAddr := base58.EncodeAddr(18, fullPubKey)
+	walletFileName := fmt.Sprintf("%s_spend", walletAddr)
+
+	var vkbvBytes [32]byte
+	copy(vkbvBytes[:], c.vkbv.Serialize())
+
+	reverse(&vkbsBytes)
+	reverse(&vkbvBytes)
+
+	genReq := rpc.GenerateFromKeysRequest{
+		Filename: walletFileName,
+		Address:  walletAddr,
+		SpendKey: hex.EncodeToString(vkbsBytes[:]),
+		ViewKey:  hex.EncodeToString(vkbvBytes[:]),
+	}
+
+	xmrChecker, err := createNewXMRWallet(ctx, genReq)
+	if err != nil {
+		return nil, err
+	}
+
+	return xmrChecker, nil
+}
+
+// takeDcr is the punish if Bob takes too long. Alice gets the dcr while bob
+// gets nothing.
+func (c *client) takeDcr(ctx context.Context, lockRefundTxScript []byte, spendRefundTx *wire.MsgTx) (err error) {
+	newAddr, err := c.dcr.GetNewAddress(ctx, "default")
+	if err != nil {
+		return err
+	}
+	p2AddrScriptVer, p2AddrScript := newAddr.PaymentScript()
+	txOut := &wire.TxOut{
+		Value:    dcrAmt - dumbFee - dumbFee,
+		Version:  p2AddrScriptVer,
+		PkScript: p2AddrScript,
+	}
+	spendRefundTx.TxOut[0] = txOut
+
+	kafSig, err := sign.RawTxInSignature(spendRefundTx, 0, lockRefundTxScript, txscript.SigHashAll, c.kaf.Serialize(), dcrec.STEcdsaSecp256k1)
+	if err != nil {
+		return err
+	}
+	refundSig, err := txscript.NewScriptBuilder().
+		AddData(kafSig).
+		AddOp(txscript.OP_FALSE).
+		AddData(lockRefundTxScript).
+		Script()
+
+	spendRefundTx.TxIn[0].SignatureScript = refundSig
+
+	_, err = c.dcr.SendRawTransaction(ctx, spendRefundTx, false)
+	if err != nil {
+		return err
+	}
+	// TODO: Confirm refund happened.
+	return nil
+}
+
+// success is a successful trade.
+func success(ctx context.Context) error {
+	alice, err := newClient(ctx, "http://127.0.0.1:28284/json_rpc", "trading1")
+	if err != nil {
+		return err
+	}
+	balReq := rpc.GetBalanceRequest{
+		AccountIndex: 0,
+	}
+	xmrBal, err := alice.xmr.GetBalance(ctx, &balReq)
+	if err != nil {
+		return err
+	}
+	fmt.Printf("alice xmr balance\n%+v\n", *xmrBal)
+
+	dcrBal, err := alice.dcr.GetBalance(ctx, "default")
+	if err != nil {
+		return err
+	}
+	dcrBeforeBal := toAtoms(dcrBal.Balances[0].Total)
+	fmt.Printf("alice dcr balance %v\n", dcrBeforeBal)
+
+	bob, err := newClient(ctx, "http://127.0.0.1:28184/json_rpc", "trading2")
+	if err != nil {
+		return err
+	}
+
+	// Alice generates dleag.
+
+	pkbsf, kbvf, pkaf, aliceDleag, err := alice.generateDleag(ctx)
+	if err != nil {
+		return err
+	}
+
+	// Bob generates transactions but does not send anything yet.
+
+	_, lockRefundTxScript, lockTxScript, refundTx, spendRefundTx, vIn, pkbs, vkbv, bobDleag, err := bob.generateLockTxn(ctx, pkbsf, kbvf, pkaf, aliceDleag)
+	if err != nil {
+		return fmt.Errorf("unalbe to generate lock transactions: %v", err)
+	}
+
+	// Alice signs a refund script for Bob.
+
+	_, _, err = alice.generateRefundSigs(refundTx, spendRefundTx, vIn, lockTxScript, lockRefundTxScript, bobDleag)
+	if err != nil {
+		return err
+	}
+
+	// Bob initializes the swap with dcr being sent.
+
+	spendTx, err := bob.initDcr(ctx)
+	if err != nil {
+		return err
+	}
+
+	// Alice inits her monero side.
+	if err := alice.initXmr(ctx, vkbv, pkbs); err != nil {
+		return err
+	}
+
+	time.Sleep(time.Second * 5)
+
+	// Bob sends esig after confirming on chain xmr tx.
+
+	bobEsig, err := bob.sendLockTxSig(lockTxScript, spendTx)
+	if err != nil {
+		return err
+	}
+
+	// Alice redeems using the esig.
+	kalSig, err := alice.redeemDcr(ctx, bobEsig, lockTxScript, spendTx)
+	if err != nil {
+		return err
+	}
+
+	// Prove that bob can't just sign the spend tx for the signature we need.
+	ks, err := sign.RawTxInSignature(spendTx, 0, lockTxScript, txscript.SigHashAll, bob.kal.Serialize(), dcrec.STEcdsaSecp256k1)
+	if err != nil {
+		return err
+	}
+	if bytes.Equal(ks, kalSig) {
+		return errors.New("bob was able to get the correct sig without alice")
+	}
+
+	// Bob redeems the xmr with the dcr signature.
+	xmrChecker, err := bob.redeemXmr(ctx, kalSig)
+	if err != nil {
+		return err
+	}
+
+	// NOTE: This wallet must sync so may take a long time on mainnet.
+	// TODO: Wait for wallet sync rather than a dumb sleep.
+	time.Sleep(time.Second * 40)
+
+	xmrBal, err = xmrChecker.GetBalance(ctx, &balReq)
+	if err != nil {
+		return err
+	}
+	if xmrBal.Balance != xmrAmt {
+		return fmt.Errorf("expected redeem xmr balance of %d but got %d", xmrAmt, xmrBal.Balance)
+	}
+
+	dcrBal, err = alice.dcr.GetBalance(ctx, "default")
+	if err != nil {
+		return err
+	}
+	dcrAfterBal := toAtoms(dcrBal.Balances[0].Total)
+	wantBal := dcrBeforeBal + dcrAmt - uint64(dumbFee)
+	if wantBal != dcrAfterBal {
+		return fmt.Errorf("expected alice balance to be %d but got %d", wantBal, dcrAfterBal)
+	}
+
+	return nil
+}
+
+// aliceBailsBeforeXmrInit is a trade that fails because alice does nothing after
+// Bob inits.
+func aliceBailsBeforeXmrInit(ctx context.Context) error {
+	alice, err := newClient(ctx, "http://127.0.0.1:28284/json_rpc", "trading1")
+	if err != nil {
+		return err
+	}
+
+	bob, err := newClient(ctx, "http://127.0.0.1:28184/json_rpc", "trading2")
+	if err != nil {
+		return err
+	}
+
+	dcrBal, err := bob.dcr.GetBalance(ctx, "default")
+	if err != nil {
+		return err
+	}
+	dcrBeforeBal := toAtoms(dcrBal.Balances[0].Total)
+
+	// Alice generates dleag.
+
+	pkbsf, kbvf, pkaf, aliceDleag, err := alice.generateDleag(ctx)
+	if err != nil {
+		return err
+	}
+
+	// Bob generates transactions but does not send anything yet.
+
+	bobRefundSig, lockRefundTxScript, lockTxScript, refundTx, spendRefundTx, vIn, _, _, bobDleag, err := bob.generateLockTxn(ctx, pkbsf, kbvf, pkaf, aliceDleag)
+	if err != nil {
+		return fmt.Errorf("unalbe to generate lock transactions: %v", err)
+	}
+
+	// Alice signs a refund script for Bob.
+
+	spendRefundESig, aliceRefundSig, err := alice.generateRefundSigs(refundTx, spendRefundTx, vIn, lockTxScript, lockRefundTxScript, bobDleag)
+	if err != nil {
+		return err
+	}
+
+	// Bob initializes the swap with dcr being sent.
+
+	_, err = bob.initDcr(ctx)
+	if err != nil {
+		return err
+	}
+
+	time.Sleep(time.Second * 5)
+
+	// Bob starts the refund.
+	if err := bob.startRefund(ctx, bobRefundSig, aliceRefundSig, lockTxScript, refundTx); err != nil {
+		return err
+	}
+
+	time.Sleep(time.Second * 5)
+
+	// Bob refunds.
+	_, err = bob.refundDcr(ctx, spendRefundTx, spendRefundESig, lockRefundTxScript)
+	if err != nil {
+		return err
+	}
+
+	time.Sleep(time.Second * 5)
+
+	dcrBal, err = bob.dcr.GetBalance(ctx, "default")
+	if err != nil {
+		return err
+	}
+
+	var initFee uint64
+	for _, input := range bob.lockTx.TxIn {
+		initFee += uint64(input.ValueIn)
+	}
+	for _, output := range bob.lockTx.TxOut {
+		initFee -= uint64(output.Value)
+	}
+
+	dcrAfterBal := toAtoms(dcrBal.Balances[0].Total)
+	wantBal := dcrBeforeBal - initFee - uint64(dumbFee)*2
+	if wantBal != dcrAfterBal {
+		return fmt.Errorf("expected bob balance to be %d but got %d", wantBal, dcrAfterBal)
+	}
+
+	return nil
+}
+
+// refund is a failed trade where both parties have sent their initial funds and
+// both get them back minus fees.
+func refund(ctx context.Context) error {
+	alice, err := newClient(ctx, "http://127.0.0.1:28284/json_rpc", "trading1")
+	if err != nil {
+		return err
+	}
+
+	bob, err := newClient(ctx, "http://127.0.0.1:28184/json_rpc", "trading2")
+	if err != nil {
+		return err
+	}
+
+	// Alice generates dleag.
+
+	pkbsf, kbvf, pkaf, aliceDleag, err := alice.generateDleag(ctx)
+	if err != nil {
+		return err
+	}
+
+	// Bob generates transactions but does not send anything yet.
+
+	bobRefundSig, lockRefundTxScript, lockTxScript, refundTx, spendRefundTx, vIn, pkbs, vkbv, bobDleag, err := bob.generateLockTxn(ctx, pkbsf, kbvf, pkaf, aliceDleag)
+	if err != nil {
+		return fmt.Errorf("unalbe to generate lock transactions: %v", err)
+	}
+
+	// Alice signs a refund script for Bob.
+
+	spendRefundESig, aliceRefundSig, err := alice.generateRefundSigs(refundTx, spendRefundTx, vIn, lockTxScript, lockRefundTxScript, bobDleag)
+	if err != nil {
+		return err
+	}
+
+	// Bob initializes the swap with dcr being sent.
+
+	_, err = bob.initDcr(ctx)
+	if err != nil {
+		return err
+	}
+
+	// Alice inits her monero side.
+	if err := alice.initXmr(ctx, vkbv, pkbs); err != nil {
+		return err
+	}
+
+	time.Sleep(time.Second * 5)
+
+	// Bob starts the refund.
+	if err := bob.startRefund(ctx, bobRefundSig, aliceRefundSig, lockTxScript, refundTx); err != nil {
+		return err
+	}
+
+	time.Sleep(time.Second * 5)
+
+	// Bob refunds.
+	kafSig, err := bob.refundDcr(ctx, spendRefundTx, spendRefundESig, lockRefundTxScript)
+	if err != nil {
+		return err
+	}
+
+	// Alice refunds.
+	xmrChecker, err := alice.refundXmr(ctx, kafSig, spendRefundESig)
+	if err != nil {
+		return err
+	}
+
+	// NOTE: This wallet must sync so may take a long time on mainnet.
+	// TODO: Wait for wallet sync rather than a dumb sleep.
+	time.Sleep(time.Second * 40)
+
+	balReq := rpc.GetBalanceRequest{}
+	bal, err := xmrChecker.GetBalance(ctx, &balReq)
+	if err != nil {
+		return err
+	}
+	if bal.Balance != xmrAmt {
+		return fmt.Errorf("expected refund xmr balance of %d but got %d", xmrAmt, bal.Balance)
+	}
+	fmt.Printf("new xmr wallet balance\n%+v\n", *bal)
+
+	return nil
+}
+
+// bobBailsAfterXmrInit is a failed trade where bob disappears after both parties
+// init and alice takes all his dcr while losing her xmr. Bob gets nothing.
+func bobBailsAfterXmrInit(ctx context.Context) error {
+	alice, err := newClient(ctx, "http://127.0.0.1:28284/json_rpc", "trading1")
+	if err != nil {
+		return err
+	}
+
+	bob, err := newClient(ctx, "http://127.0.0.1:28184/json_rpc", "trading2")
+	if err != nil {
+		return err
+	}
+
+	dcrBal, err := alice.dcr.GetBalance(ctx, "default")
+	if err != nil {
+		return err
+	}
+	dcrBeforeBal := toAtoms(dcrBal.Balances[0].Total)
+
+	// Alice generates dleag.
+
+	pkbsf, kbvf, pkaf, aliceDleag, err := alice.generateDleag(ctx)
+	if err != nil {
+		return err
+	}
+
+	// Bob generates transactions but does not send anything yet.
+
+	bobRefundSig, lockRefundTxScript, lockTxScript, refundTx, spendRefundTx, vIn, pkbs, vkbv, bobDleag, err := bob.generateLockTxn(ctx, pkbsf, kbvf, pkaf, aliceDleag)
+	if err != nil {
+		return fmt.Errorf("unalbe to generate lock transactions: %v", err)
+	}
+
+	// Alice signs a refund script for Bob.
+
+	_, aliceRefundSig, err := alice.generateRefundSigs(refundTx, spendRefundTx, vIn, lockTxScript, lockRefundTxScript, bobDleag)
+	if err != nil {
+		return err
+	}
+
+	// Bob initializes the swap with dcr being sent.
+
+	_, err = bob.initDcr(ctx)
+	if err != nil {
+		return err
+	}
+
+	// Alice inits her monero side.
+	if err := alice.initXmr(ctx, vkbv, pkbs); err != nil {
+		return err
+	}
+
+	time.Sleep(time.Second * 5)
+
+	// Alice starts the refund.
+	if err := alice.startRefund(ctx, bobRefundSig, aliceRefundSig, lockTxScript, refundTx); err != nil {
+		return err
+	}
+
+	// Lessen this sleep for failure. Two blocks must be mined for success.
+	time.Sleep(time.Second * 35)
+
+	if err := alice.takeDcr(ctx, lockRefundTxScript, spendRefundTx); err != nil {
+		return err
+	}
+
+	time.Sleep(time.Second * 5)
+
+	dcrBal, err = alice.dcr.GetBalance(ctx, "default")
+	if err != nil {
+		return err
+	}
+
+	dcrAfterBal := toAtoms(dcrBal.Balances[0].Total)
+	wantBal := dcrBeforeBal + dcrAmt - uint64(dumbFee)*2
+	if wantBal != dcrAfterBal {
+		return fmt.Errorf("expected alice balance to be %d but got %d", wantBal, dcrAfterBal)
+	}
+	return nil
+}
diff --git a/internal/libsecp256k1/README.md b/internal/libsecp256k1/README.md
new file mode 100644
index 0000000000..5112e5c0f6
--- /dev/null
+++ b/internal/libsecp256k1/README.md
@@ -0,0 +1,10 @@
+### Package libsecp256k1
+
+Package libsecp256k1 includes some primative cryptographic functions needed for
+working with adaptor signatures that are not currently found in golang. This imports
+code from https://github.com/tecnovert/secp256k1 and uses that with cgo. Both
+that library and this package are in an experimental stage.
+
+### Usage
+
+Run the `build.sh` script. Currently untested on mac and will not work on Windows.
diff --git a/internal/libsecp256k1/build.sh b/internal/libsecp256k1/build.sh
new file mode 100755
index 0000000000..b19343f0c7
--- /dev/null
+++ b/internal/libsecp256k1/build.sh
@@ -0,0 +1,10 @@
+#!/usr/bin/env bash
+
+rm -fr secp256k1
+git clone https://github.com/tecnovert/secp256k1 -b anonswap_v0.2
+
+cd secp256k1
+./autogen.sh
+./configure --enable-module-dleag --enable-experimental --enable-module-generator --enable-module-ed25519 --enable-module-recovery --enable-module-ecdsaotves
+make
+cd ..
diff --git a/internal/libsecp256k1/libsecp256k1.go b/internal/libsecp256k1/libsecp256k1.go
new file mode 100644
index 0000000000..637435cc79
--- /dev/null
+++ b/internal/libsecp256k1/libsecp256k1.go
@@ -0,0 +1,149 @@
+// This code is available on the terms of the project LICENSE.md file,
+// also available online at https://blueoakcouncil.org/license/1.0.0.
+
+package libsecp256k1
+
+/*
+#cgo CFLAGS: -g -Wall
+#cgo LDFLAGS: -L. -l:secp256k1/.libs/libsecp256k1.a
+#include "secp256k1/include/secp256k1_dleag.h"
+#include "secp256k1/include/secp256k1_ecdsaotves.h"
+#include <stdlib.h>
+
+secp256k1_context* _ctx() {
+	return secp256k1_context_create(SECP256K1_CONTEXT_SIGN | SECP256K1_CONTEXT_VERIFY);
+}
+*/
+import "C"
+import (
+	"errors"
+	"unsafe"
+
+	"decred.org/dcrdex/dex/encode"
+	"github.com/decred/dcrd/dcrec/edwards/v2"
+	"github.com/decred/dcrd/dcrec/secp256k1/v4"
+)
+
+const (
+	ProofLen  = 48893
+	CTLen     = 196
+	maxSigLen = 72 // The actual size is variable.
+)
+
+// Ed25519DleagProve creates a proof for checking a discrete logarithm is equal
+// across the secp256k1 and ed25519 curves.
+func Ed25519DleagProve(privKey *edwards.PrivateKey) (proof [ProofLen]byte, err error) {
+	secpCtx := C._ctx()
+	defer C.free(unsafe.Pointer(secpCtx))
+	nonce := [32]byte{}
+	copy(nonce[:], encode.RandomBytes(32))
+	key := [32]byte{}
+	copy(key[:], privKey.Serialize())
+	n := (*C.uchar)(unsafe.Pointer(&nonce))
+	k := (*C.uchar)(unsafe.Pointer(&key))
+	nBits := uint64(252)
+	nb := (*C.ulong)(unsafe.Pointer(&nBits))
+	plen := C.ulong(ProofLen)
+	p := (*C.uchar)(unsafe.Pointer(&proof))
+	res := C.secp256k1_ed25519_dleag_prove(secpCtx, p, &plen, k, *nb, n)
+	if int(res) != 1 {
+		return [ProofLen]byte{}, errors.New("C.secp256k1_ed25519_dleag_prove exited with error")
+	}
+	return proof, nil
+}
+
+// Ed25519DleagVerify verifies that a descrete logarithm is equal across the
+// secp256k1 and ed25519 curves.
+func Ed25519DleagVerify(proof [ProofLen]byte) bool {
+	secpCtx := C._ctx()
+	defer C.free(unsafe.Pointer(secpCtx))
+	pl := C.ulong(ProofLen)
+	p := (*C.uchar)(unsafe.Pointer(&proof))
+	res := C.secp256k1_ed25519_dleag_verify(secpCtx, p, pl)
+	return res == 1
+}
+
+// EcdsaotvesEncSign signs the hash and returns an encrypted signature.
+func EcdsaotvesEncSign(signPriv *secp256k1.PrivateKey, encPub *secp256k1.PublicKey, hash [32]byte) (cyphertext [CTLen]byte, err error) {
+	secpCtx := C._ctx()
+	defer C.free(unsafe.Pointer(secpCtx))
+	privBytes := [32]byte{}
+	copy(privBytes[:], signPriv.Serialize())
+	priv := (*C.uchar)(unsafe.Pointer(&privBytes))
+	pubBytes := [33]byte{}
+	copy(pubBytes[:], encPub.SerializeCompressed())
+	pub := (*C.uchar)(unsafe.Pointer(&pubBytes))
+	h := (*C.uchar)(unsafe.Pointer(&hash))
+	s := (*C.uchar)(unsafe.Pointer(&cyphertext))
+	res := C.ecdsaotves_enc_sign(secpCtx, s, priv, pub, h)
+	if int(res) != 1 {
+		return [CTLen]byte{}, errors.New("C.ecdsaotves_enc_sign exited with error")
+	}
+	return cyphertext, nil
+}
+
+// EcdsaotvesEncVerify verifies the encrypted signature.
+func EcdsaotvesEncVerify(signPub, encPub *secp256k1.PublicKey, hash [32]byte, cyphertext [CTLen]byte) bool {
+	secpCtx := C._ctx()
+	defer C.free(unsafe.Pointer(secpCtx))
+	signBytes := [33]byte{}
+	copy(signBytes[:], signPub.SerializeCompressed())
+	sp := (*C.uchar)(unsafe.Pointer(&signBytes))
+	encBytes := [33]byte{}
+	copy(encBytes[:], encPub.SerializeCompressed())
+	ep := (*C.uchar)(unsafe.Pointer(&encBytes))
+	h := (*C.uchar)(unsafe.Pointer(&hash))
+	c := (*C.uchar)(unsafe.Pointer(&cyphertext))
+	res := C.ecdsaotves_enc_verify(secpCtx, sp, ep, h, c)
+	return res == 1
+}
+
+// EcdsaotvesDecSig retrieves the signature.
+func EcdsaotvesDecSig(encPriv *secp256k1.PrivateKey, cyphertext [CTLen]byte) ([]byte, error) {
+	secpCtx := C._ctx()
+	defer C.free(unsafe.Pointer(secpCtx))
+	encBytes := [32]byte{}
+	copy(encBytes[:], encPriv.Serialize())
+	ep := (*C.uchar)(unsafe.Pointer(&encBytes))
+	ct := (*C.uchar)(unsafe.Pointer(&cyphertext))
+	var sig [maxSigLen]byte
+	s := (*C.uchar)(unsafe.Pointer(&sig))
+	slen := C.ulong(maxSigLen)
+	res := C.ecdsaotves_dec_sig(secpCtx, s, &slen, ep, ct)
+	if int(res) != 1 {
+		return nil, errors.New("C.ecdsaotves_dec_sig exited with error")
+	}
+	sigCopy := make([]byte, maxSigLen)
+	copy(sigCopy, sig[:])
+	// Remove trailing zeros.
+	for i := maxSigLen - 1; i >= 0; i-- {
+		if sigCopy[i] != 0 {
+			break
+		}
+		sigCopy = sigCopy[:i]
+	}
+	return sigCopy, nil
+}
+
+// EcdsaotvesRecEncKey retrieves the encoded private key from signature and
+// cyphertext.
+func EcdsaotvesRecEncKey(encPub *secp256k1.PublicKey, cyphertext [CTLen]byte, sig []byte) (encPriv *secp256k1.PrivateKey, err error) {
+	secpCtx := C._ctx()
+	defer C.free(unsafe.Pointer(secpCtx))
+	pubBytes := [33]byte{}
+	copy(pubBytes[:], encPub.SerializeCompressed())
+	ep := (*C.uchar)(unsafe.Pointer(&pubBytes))
+	ct := (*C.uchar)(unsafe.Pointer(&cyphertext))
+	sigCopy := [maxSigLen]byte{}
+	copy(sigCopy[:], sig)
+	s := (*C.uchar)(unsafe.Pointer(&sigCopy))
+	varSigLen := len(sig)
+	slen := C.ulong(varSigLen)
+	pkBytes := [32]byte{}
+	pk := (*C.uchar)(unsafe.Pointer(&pkBytes))
+	res := C.ecdsaotves_rec_enc_key(secpCtx, pk, ep, ct, s, slen)
+	if int(res) != 1 {
+		return nil, errors.New("C.ecdsaotves_rec_enc_key exited with error")
+	}
+	return secp256k1.PrivKeyFromBytes(pkBytes[:]), nil
+}
diff --git a/internal/libsecp256k1/libsecp256k1_test.go b/internal/libsecp256k1/libsecp256k1_test.go
new file mode 100644
index 0000000000..fd16d6e97f
--- /dev/null
+++ b/internal/libsecp256k1/libsecp256k1_test.go
@@ -0,0 +1,215 @@
+//go:build libsecp256k1
+
+package libsecp256k1
+
+import (
+	"bytes"
+	"math/rand"
+	"testing"
+
+	"github.com/decred/dcrd/dcrec/edwards/v2"
+	"github.com/decred/dcrd/dcrec/secp256k1/v4"
+)
+
+func randBytes(n int) []byte {
+	b := make([]byte, n)
+	rand.Read(b)
+	return b
+}
+
+func TestEd25519DleagProve(t *testing.T) {
+	tests := []struct {
+		name string
+	}{{
+		name: "ok",
+	}}
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			pk, err := edwards.GeneratePrivateKey()
+			if err != nil {
+				t.Fatal(err)
+			}
+			sPk := secp256k1.PrivKeyFromBytes(pk.Serialize())
+			proof, err := Ed25519DleagProve(pk)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if !bytes.Equal(sPk.PubKey().SerializeCompressed(), proof[:33]) {
+				t.Fatal("first 33 bytes of proof not equal to secp256k1 pubkey")
+			}
+		})
+	}
+}
+
+func TestEd25519DleagVerify(t *testing.T) {
+	pk, err := edwards.GeneratePrivateKey()
+	if err != nil {
+		panic(err)
+	}
+	proof, err := Ed25519DleagProve(pk)
+	if err != nil {
+		panic(err)
+	}
+	tests := []struct {
+		name  string
+		proof [ProofLen]byte
+		ok    bool
+	}{{
+		name:  "ok",
+		proof: proof,
+		ok:    true,
+	}, {
+		name: "bad proof",
+		proof: func() (p [ProofLen]byte) {
+			copy(p[:], proof[:])
+			p[0] ^= p[0]
+			return p
+		}(),
+	}}
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			ok := Ed25519DleagVerify(test.proof)
+			if ok != test.ok {
+				t.Fatalf("want %v but got %v", test.ok, ok)
+			}
+		})
+	}
+}
+
+func TestEcdsaotvesEncSign(t *testing.T) {
+	tests := []struct {
+		name string
+	}{{
+		name: "ok",
+	}}
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			signPk, err := secp256k1.GeneratePrivateKey()
+			if err != nil {
+				t.Fatal(err)
+			}
+			encPk, err := secp256k1.GeneratePrivateKey()
+			if err != nil {
+				t.Fatal(err)
+			}
+			h := randBytes(32)
+			var hash [32]byte
+			copy(hash[:], h)
+			_, err = EcdsaotvesEncSign(signPk, encPk.PubKey(), hash)
+			if err != nil {
+				t.Fatal(err)
+			}
+		})
+	}
+}
+
+func TestEcdsaotvesEncVerify(t *testing.T) {
+	signPk, err := secp256k1.GeneratePrivateKey()
+	if err != nil {
+		t.Fatal(err)
+	}
+	encPk, err := secp256k1.GeneratePrivateKey()
+	if err != nil {
+		t.Fatal(err)
+	}
+	h := randBytes(32)
+	var hash [32]byte
+	copy(hash[:], h)
+	ct, err := EcdsaotvesEncSign(signPk, encPk.PubKey(), hash)
+	if err != nil {
+		t.Fatal(err)
+	}
+	tests := []struct {
+		name string
+		ok   bool
+		ct   [196]byte
+	}{{
+		name: "ok",
+		ct:   ct,
+		ok:   true,
+	}, {
+		name: "bad sig",
+		ct: func() (c [CTLen]byte) {
+			copy(c[:], ct[:])
+			c[0] ^= c[0]
+			return c
+		}(),
+	}}
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			ok := EcdsaotvesEncVerify(signPk.PubKey(), encPk.PubKey(), hash, test.ct)
+			if ok != test.ok {
+				t.Fatalf("want %v but got %v", test.ok, ok)
+			}
+		})
+	}
+}
+
+func TestEcdsaotvesDecSig(t *testing.T) {
+	signPk, err := secp256k1.GeneratePrivateKey()
+	if err != nil {
+		t.Fatal(err)
+	}
+	encPk, err := secp256k1.GeneratePrivateKey()
+	if err != nil {
+		t.Fatal(err)
+	}
+	h := randBytes(32)
+	var hash [32]byte
+	copy(hash[:], h)
+	ct, err := EcdsaotvesEncSign(signPk, encPk.PubKey(), hash)
+	if err != nil {
+		t.Fatal(err)
+	}
+	tests := []struct {
+		name string
+	}{{
+		name: "ok",
+	}}
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			_, err := EcdsaotvesDecSig(encPk, ct)
+			if err != nil {
+				t.Fatal(err)
+			}
+		})
+	}
+}
+
+func TestEcdsaotvesRecEncKey(t *testing.T) {
+	signPk, err := secp256k1.GeneratePrivateKey()
+	if err != nil {
+		t.Fatal(err)
+	}
+	encPk, err := secp256k1.GeneratePrivateKey()
+	if err != nil {
+		t.Fatal(err)
+	}
+	h := randBytes(32)
+	var hash [32]byte
+	copy(hash[:], h)
+	ct, err := EcdsaotvesEncSign(signPk, encPk.PubKey(), hash)
+	if err != nil {
+		t.Fatal(err)
+	}
+	sig, err := EcdsaotvesDecSig(encPk, ct)
+	if err != nil {
+		t.Fatal(err)
+	}
+	tests := []struct {
+		name string
+	}{{
+		name: "ok",
+	}}
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			pk, err := EcdsaotvesRecEncKey(encPk.PubKey(), ct, sig)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if !bytes.Equal(pk.Serialize(), encPk.Serialize()) {
+				t.Fatal("private keys not equal")
+			}
+		})
+	}
+}
diff --git a/internal/libsecp256k1/secp256k1 b/internal/libsecp256k1/secp256k1
new file mode 160000
index 0000000000..e3ebcd782a
--- /dev/null
+++ b/internal/libsecp256k1/secp256k1
@@ -0,0 +1 @@
+Subproject commit e3ebcd782a604f228784b10c50ffa099d9796720
diff --git a/run_tests.sh b/run_tests.sh
index fa1923bb57..1ec7227cab 100755
--- a/run_tests.sh
+++ b/run_tests.sh
@@ -9,6 +9,12 @@ echo "Go version: $GV"
 # Ensure html templates pass localization.
 go generate -x ./client/webserver/site # no -write
 
+cd ./internal/libsecp256k1
+./build.sh
+go test -race -tags libsecp256k1
+
+cd "$dir"
+
 # list of all modules to test
 modules=". /dex/testing/loadbot /client/cmd/bisonw-desktop"