Add incoming mweb->plain amounts to unconfirmed balance

basicswap-prepare will set trusted_daemon true if the daemon host address is a local ip address else false.
Override with --trustremotenode
--trustremotenode can be used with --enabletor

.cirrus.yml

@@ -7,8 +7,8 @@ lint_task:
     - pip install codespell
   script:
     - flake8 --version
-    - PYTHONWARNINGS="ignore" flake8 --ignore=E501,F841,W503 --exclude=basicswap/contrib,messages_pb2.py,.eggs,.tox
-    - codespell --check-filenames --disable-colors --quiet-level=7 --ignore-words=tests/lint/spelling.ignore-words.txt -S .git,.eggs,.tox,gitianpubkeys,*.pyc,*basicswap/contrib,*mnemonics.py
+    - PYTHONWARNINGS="ignore" flake8 --ignore=E501,F841,W503 --exclude=basicswap/contrib,basicswap/interface/contrib,messages_pb2.py,.eggs,.tox,bin/install_certifi.py
+    - codespell --check-filenames --disable-colors --quiet-level=7 --ignore-words=tests/lint/spelling.ignore-words.txt -S .git,.eggs,.tox,pgp,*.pyc,*basicswap/contrib,*basicswap/interface/contrib,*mnemonics.py,bin/install_certifi.py,*basicswap/static
 
 test_task:
   environment:
@@ -24,8 +24,9 @@ test_task:
     - apt-get install -y wget python3-pip gnupg unzip protobuf-compiler automake libtool pkg-config
     - pip install tox pytest
     - python3 setup.py install
-    - wget -O coincurve-anonswap.zip https://github.com/tecnovert/coincurve/archive/anonswap.zip
-    - unzip coincurve-anonswap.zip
+    - wget -O coincurve-anonswap.zip https://github.com/tecnovert/coincurve/archive/refs/tags/anonswap_v0.2.zip
+    - unzip -d coincurve-anonswap coincurve-anonswap.zip
+    - mv ./coincurve-anonswap/*/{.,}* ./coincurve-anonswap || true
     - cd coincurve-anonswap
     - python3 setup.py install --force
   bins_cache:
@@ -46,3 +47,4 @@ test_task:
     - pytest tests/basicswap/test_other.py
     - pytest tests/basicswap/test_run.py
     - pytest tests/basicswap/test_reload.py
+    - pytest tests/basicswap/test_btc_xmr.py -k 'test_01_a or test_01_b or test_02_a or test_02_b'

.gitignore

@@ -1,4 +1,5 @@
 old/
+build/
 *.pyc
 __pycache__
 /dist/
@@ -8,3 +9,6 @@ __pycache__
 .tox
 .eggs
 *~
+
+# geckodriver.log
+*.log

.travis.yml

@@ -22,8 +22,9 @@ before_install:
 install:
   - travis_retry pip install tox pytest
 before_script:
-  - wget -O coincurve-anonswap.zip https://github.com/tecnovert/coincurve/archive/anonswap.zip
-  - unzip coincurve-anonswap.zip
+  - wget -O coincurve-anonswap.zip https://github.com/tecnovert/coincurve/archive/refs/tags/anonswap_v0.2.zip
+  - unzip -d coincurve-anonswap coincurve-anonswap.zip
+  - mv ./coincurve-anonswap/*/{.,}* ./coincurve-anonswap || true
   - cd coincurve-anonswap
   - python3 setup.py install --force
 script:
@@ -51,8 +52,8 @@ jobs:
         - travis_retry pip install codespell==1.15.0
       before_script:
       script:
-        - PYTHONWARNINGS="ignore" flake8 --ignore=E501,F841,W503 --exclude=basicswap/contrib,messages_pb2.py,.eggs,.tox
-        - codespell --check-filenames --disable-colors --quiet-level=7 --ignore-words=tests/lint/spelling.ignore-words.txt -S .git,.eggs,.tox,gitianpubkeys,*.pyc,*basicswap/contrib,*mnemonics.py
+        - PYTHONWARNINGS="ignore" flake8 --ignore=E501,F841,W503 --exclude=basicswap/contrib,basicswap/interface/contrib,messages_pb2.py,.eggs,.tox,bin/install_certifi.py
+        - codespell --check-filenames --disable-colors --quiet-level=7 --ignore-words=tests/lint/spelling.ignore-words.txt -S .git,.eggs,.tox,pgp,*.pyc,*basicswap/contrib,*basicswap/interface/contrib,*mnemonics.py,bin/install_certifi.py,*basicswap/static
       after_success:
         - echo "End lint"
     - stage: test

Dockerfile

@@ -1,14 +1,24 @@
-FROM ubuntu:20.04
+FROM ubuntu:22.04
 
 ENV LANG=C.UTF-8 \
     DEBIAN_FRONTEND=noninteractive \
     DATADIRS="/coindata"
 
 RUN apt-get update; \
-    apt-get install -y wget python3-pip gnupg unzip protobuf-compiler automake libtool pkg-config gosu tzdata;
+    apt-get install -y wget python3-pip gnupg unzip make g++ autoconf automake libtool pkg-config gosu tzdata;
 
-RUN wget -O coincurve-anonswap.zip https://github.com/tecnovert/coincurve/archive/anonswap.zip && \
+# Must install protoc directly as latest package is only on 3.12
+RUN wget -O protobuf_src.tar.gz https://github.com/protocolbuffers/protobuf/releases/download/v21.1/protobuf-python-4.21.1.tar.gz && \
+    tar xvf protobuf_src.tar.gz && \
+    cd protobuf-3.21.1 && \
+    ./configure --prefix=/usr && \
+    make -j$(nproc) install && \
+    ldconfig
+
+ARG COINCURVE_VERSION=v0.2
+RUN wget -O coincurve-anonswap.zip https://github.com/tecnovert/coincurve/archive/refs/tags/anonswap_$COINCURVE_VERSION.zip && \
     unzip coincurve-anonswap.zip && \
+    mv ./coincurve-anonswap_$COINCURVE_VERSION ./coincurve-anonswap && \
     cd coincurve-anonswap && \
     python3 setup.py install --force
 
@@ -24,8 +34,10 @@ RUN cd basicswap-master; \
 RUN useradd -ms /bin/bash swap_user && \
     mkdir /coindata && chown swap_user -R /coindata
 
-# Expose html port
+# html port
 EXPOSE 12700
+# websocket port
+EXPOSE 11700
 
 VOLUME /coindata
 

LICENSE

@@ -1,5 +1,5 @@
 The MIT License (MIT)
-Copyright (c) 2019 tecnovert
+Copyright (c) 2019-2024 tecnovert
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

README.md

@@ -1,20 +1,131 @@
+# BasicSwap DEX (BSX)
 
-# Simple Atomic Swap Network - Proof of Concept
+![BasicswapDEX Preview](.github-readme/basicswap_header.jpg)
 
-## Overview
+**[Official Website](https://basicswapdex.com)** | **[News](https://particl.news)** | **[Tutorials](https://academy.particl.io)** | **[Chat]( https://matrix.to/#/#basicswap:matrix.org )**
 
-Simple atomic swap experiment, doesn't have many interesting features yet.
-Not ready for real world use.
+Table of Contents
 
-Uses Particl secure messaging and Decred style atomic swaps.
+* [About](#about)
+* [Features](#features)
+* [Available Assets](#available-assets)
+* [Participate](#participate)
+* [Tutorials](#tutorials)
+* [License](#license)
 
-The Particl node is used to hold the keys and sign for the swap transactions.
-Other nodes can be run in pruned mode.
-A node must be run for each coin type traded.
-In the future it should be possible to use data from explorers instead of running a node.
+## About
 
-## Currently a work in progress
+The BasicSwap DEX is a privacy-first and decentralized exchange which features cross-chain atomic swaps and a distributed order book.
 
-Not ready for real-world use.
+[BasicSwap](https://academy.particl.io/en/latest/glossary.html#term-BasicSwap) is a cross-chain and privacy-centric DEX (decentralized exchange) that lets you trade cryptocurrencies with no third party involvement. Its distributed order book lets you make or take orders at no cost and trade within a free and open environment without central points of failure.
 
-Discuss development and help with testing in the matrix channel [#basicswap:matrix.org](https://riot.im/app/#/room/#basicswap:matrix.org)
+This DEX protocol was built in direct response to the increasingly invasive demands and data mining practices of today’s cryptocurrency exchanges. It strives to bring more decentralized and more private cryptocurrency trading conditions for all.
+
+BasicSwap is still in beta. This means that, while it already offers most of the vital trading features you’d expect to see on centralized exchanges, it is still in heavy development, and many more features will come about in the near future.
+
+Check out our [roadmap](https://basicswapdex.com/roadmap) to get a better idea of what we've got planned for it!
+
+## Features
+
+* **True cross-chain support** — Swap cryptocurrencies that live on entirely different blockchain environments, like Bitcoin and Monero.
+* **Distributed order book** — Make or take limit orders on a completely distributed order book system.
+* **No third-party or middleman** — Trade crypto with no intermediaries whatsoever.
+* **No trading fees** — Only pay the typical cryptocurrency network fee.
+* **Privacy from the ground up** — Every component of BasicSwap is built with a privacy-first commitment.
+* **Full Monero support** — Swap Monero with a variety of other cryptocurrencies like Bitcoin or Particl. No wrapped assets or trickery involved.
+* **User-friendly interface** — Enjoy all these features within a user-friendly and intuitive interface that handles all the complicated parts for you.
+
+BasicSwap is still in beta. This means that, while it already offers most of the vital trading features you’d expect to see on centralized exchanges, it is still in heavy development, and many more features will come about in the near future.
+
+## Available Assets
+
+BasicSwap is compatible with the following digital assets.
+
+<table>
+  <tr>
+   <td><strong>Coin Name</strong>
+   </td>
+   <td><strong>Ticker</strong>
+   </td>
+  </tr>
+  <tr>
+   <td>Bitcoin
+   </td>
+   <td>BTC
+   </td>
+  </tr>
+  <tr>
+   <td>Monero
+   </td>
+   <td>XMR
+   </td>
+  </tr>
+  <tr>
+   <td>Dash
+   </td>
+   <td>DASH
+   </td>
+  </tr>
+  <tr>
+   <td>Litecoin
+   </td>
+   <td>LTC
+   </td>
+  </tr>
+  <tr>
+   <td>Firo
+   </td>
+   <td>FIRO
+   </td>
+  </tr>
+  <tr>
+   <td>PIVX
+   </td>
+   <td>PIVX
+   </td>
+  </tr>
+  <tr>
+   <td>Particl
+   </td>
+   <td>PART
+   </td>
+  </tr>
+</table>
+
+We plan on adding many other cryptocurrencies moving forward, including ETH and its ERC-20 tokens. However, due to the true cross-chain nature of the BasicSwap DEX protocol, each integration has to be done on a case-by-case basis.
+
+If you’d like to add a cryptocurrency to BasicSwap, either [apply for a listing using our listing application form](https://forms.gle/9DsHoHTJVqSiMNHW9), or try coding the integration yourself by referencing how other cryptocurrencies have been added. Follow [this link](https://academy.particl.io/en/latest/basicswap-guides/basicswapguides_apply.html) for more information on how to integrate a coin yourself.
+
+# Participate
+
+### Chats
+
+* **For developers** The chat [#particl-dev:matrix.org](https://app.element.io/#/room/#particl-dev:matrix.org) using [Element](https://element.io) (formerly Riot).
+* **For community** The community chat [https://discord.me/particl](https://discord.me/particl) [![Discord](https://img.shields.io/discord/391967609660112925)](https://discord.me/particl).
+
+[![Twitter Follow](https://img.shields.io/twitter/follow/BasicSwapDEX?label=follow%20us&style=social)](http://twitter.com/BasicSwapDEX)
+[![Subreddit subscribers](https://img.shields.io/reddit/subreddit-subscribers/particl?style=social)](http://reddit.com/r/particl)
+
+### Documentation, installation
+
+For non-developers curious to explore a new world of commerce, binaries can be downloaded and installed. It is the easiest way to get started. Following the guides on [Particl Academy](https://academy.particl.io), a reference book in straightforward language, is recommended.
+
+* [Download BasicSwapDEX](https://github.com/tecnovert/basicswap/tree/master/doc)
+
+#### Community chat support
+
+* [Discord](https://discord.me/particl) navigate to the #support channel
+
+* [Telegram](https://t.me/particlhelp)
+
+* [Element](https://app.element.io/#/room/#particlhelp:matrix.org)
+
+# Tutorials
+
+You can find a wide variety of tutorials and step-by-step guides about BasicSwap on the [Particl Academy](https://academy.particl.io) or on Particl’s Youtube channel.
+
+If you encounter an issue or try to accomplish something not mentioned in any of the tutorials included in the links above, please join the community chat support channels; you’ll be sure to find help and support from our awesome community and open-source team there!
+
+# License
+
+BasicSwap is released under MIT software license.

basicswap/__init__.py

@@ -1,3 +1,3 @@
 name = "basicswap"
 
-__version__ = "0.0.31"
+__version__ = "0.12.7"

basicswap/base.py

@@ -1,16 +1,22 @@
 # -*- coding: utf-8 -*-
 
-# Copyright (c) 2019-2021 tecnovert
+# Copyright (c) 2019-2024 tecnovert
 # Distributed under the MIT software license, see the accompanying
 # file LICENSE or http://www.opensource.org/licenses/mit-license.php.
 
 import os
+import time
+import shlex
+import socks
+import random
+import socket
+import urllib
 import logging
 import threading
+import traceback
 import subprocess
 
-import basicswap.config as cfg
-import basicswap.contrib.segwit_addr as segwit_addr
+from sockshandler import SocksiPyHandler
 
 from .rpc import (
     callrpc,
@@ -24,12 +30,16 @@ from .chainparams import (
 )
 
 
+def getaddrinfo_tor(*args):
+    return [(socket.AF_INET, socket.SOCK_STREAM, 6, "", (args[0], args[1]))]
+
+
 class BaseApp:
     def __init__(self, fp, data_dir, settings, chain, log_name='BasicSwap'):
         self.log_name = log_name
         self.fp = fp
-        self.is_running = True
         self.fail_code = 0
+        self.mock_time_offset = 0
 
         self.data_dir = data_dir
         self.chain = chain
@@ -39,14 +49,25 @@ class BaseApp:
         self.mxDB = threading.RLock()
         self.debug = self.settings.get('debug', False)
         self.delay_event = threading.Event()
+        self.chainstate_delay_event = threading.Event()
+
         self._network = None
         self.prepareLogging()
         self.log.info('Network: {}'.format(self.chain))
 
+        self.use_tor_proxy = self.settings.get('use_tor', False)
+        self.tor_proxy_host = self.settings.get('tor_proxy_host', '127.0.0.1')
+        self.tor_proxy_port = self.settings.get('tor_proxy_port', 9050)
+        self.tor_control_password = self.settings.get('tor_control_password', None)
+        self.tor_control_port = self.settings.get('tor_control_port', 9051)
+        self.default_socket = socket.socket
+        self.default_socket_timeout = socket.getdefaulttimeout()
+        self.default_socket_getaddrinfo = socket.getaddrinfo
+
     def stopRunning(self, with_code=0):
         self.fail_code = with_code
         with self.mxDB:
-            self.is_running = False
+            self.chainstate_delay_event.set()
             self.delay_event.set()
 
     def prepareLogging(self):
@@ -56,10 +77,10 @@ class BaseApp:
         # Remove any existing handlers
         self.log.handlers = []
 
-        formatter = logging.Formatter('%(asctime)s %(levelname)s : %(message)s')
+        formatter = logging.Formatter('%(asctime)s %(levelname)s : %(message)s', '%Y-%m-%d %H:%M:%S')
         stream_stdout = logging.StreamHandler()
         if self.log_name != 'BasicSwap':
-            stream_stdout.setFormatter(logging.Formatter('%(asctime)s %(name)s %(levelname)s : %(message)s'))
+            stream_stdout.setFormatter(logging.Formatter('%(asctime)s %(name)s %(levelname)s : %(message)s', '%Y-%m-%d %H:%M:%S'))
         else:
             stream_stdout.setFormatter(formatter)
         stream_fp = logging.StreamHandler(self.fp)
@@ -75,7 +96,7 @@ class BaseApp:
         except Exception:
             return {}
 
-    def setDaemonPID(self, name, pid):
+    def setDaemonPID(self, name, pid) -> None:
         if isinstance(name, Coins):
             self.coin_clients[name]['pid'] = pid
             return
@@ -83,54 +104,123 @@ class BaseApp:
             if v['name'] == name:
                 v['pid'] = pid
 
-    def getChainDatadirPath(self, coin):
+    def getChainDatadirPath(self, coin) -> str:
         datadir = self.coin_clients[coin]['datadir']
         testnet_name = '' if self.chain == 'mainnet' else chainparams[coin][self.chain].get('name', self.chain)
         return os.path.join(datadir, testnet_name)
 
-    def getCoinIdFromName(self, coin_name):
+    def getCoinIdFromName(self, coin_name: str):
         for c, params in chainparams.items():
             if coin_name.lower() == params['name'].lower():
                 return c
         raise ValueError('Unknown coin: {}'.format(coin_name))
 
-    def encodeSegwit(self, coin_type, raw):
-        return segwit_addr.encode(chainparams[coin_type][self.chain]['hrp'], 0, raw)
-
-    def decodeSegwit(self, coin_type, addr):
-        return bytes(segwit_addr.decode(chainparams[coin_type][self.chain]['hrp'], addr)[1])
-
     def callrpc(self, method, params=[], wallet=None):
-        return callrpc(self.coin_clients[Coins.PART]['rpcport'], self.coin_clients[Coins.PART]['rpcauth'], method, params, wallet)
+        cc = self.coin_clients[Coins.PART]
+        return callrpc(cc['rpcport'], cc['rpcauth'], method, params, wallet, cc['rpchost'])
 
     def callcoinrpc(self, coin, method, params=[], wallet=None):
-        return callrpc(self.coin_clients[coin]['rpcport'], self.coin_clients[coin]['rpcauth'], method, params, wallet)
-
-    def calltx(self, cmd):
-        bindir = self.coin_clients[Coins.PART]['bindir']
-        command_tx = os.path.join(bindir, cfg.PARTICL_TX)
-        chainname = '' if self.chain == 'mainnet' else (' -' + self.chain)
-        args = command_tx + chainname + ' ' + cmd
-        p = subprocess.Popen(args, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True)
-        out = p.communicate()
-        if len(out[1]) > 0:
-            raise ValueError('TX error ' + str(out[1]))
-        return out[0].decode('utf-8').strip()
+        cc = self.coin_clients[coin]
+        return callrpc(cc['rpcport'], cc['rpcauth'], method, params, wallet, cc['rpchost'])
 
     def callcoincli(self, coin_type, params, wallet=None, timeout=None):
         bindir = self.coin_clients[coin_type]['bindir']
         datadir = self.coin_clients[coin_type]['datadir']
         command_cli = os.path.join(bindir, chainparams[coin_type]['name'] + '-cli' + ('.exe' if os.name == 'nt' else ''))
-        chainname = '' if self.chain == 'mainnet' else (' -' + self.chain)
-        args = command_cli + chainname + ' ' + '-datadir=' + datadir + ' ' + params
-        p = subprocess.Popen(args, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True)
+        args = [command_cli, ]
+        if self.chain != 'mainnet':
+            args.append('-' + self.chain)
+        args.append('-datadir=' + datadir)
+        args += shlex.split(params)
+        p = subprocess.Popen(args, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
         out = p.communicate(timeout=timeout)
         if len(out[1]) > 0:
             raise ValueError('CLI error ' + str(out[1]))
         return out[0].decode('utf-8').strip()
 
-    def is_transient_error(self, ex):
+    def is_transient_error(self, ex) -> bool:
         if isinstance(ex, TemporaryError):
             return True
         str_error = str(ex).lower()
         return 'read timed out' in str_error or 'no connection to daemon' in str_error
+
+    def setConnectionParameters(self, timeout=120):
+        opener = urllib.request.build_opener()
+        opener.addheaders = [('User-agent', 'Mozilla/5.0')]
+        urllib.request.install_opener(opener)
+
+        if self.use_tor_proxy:
+            socks.setdefaultproxy(socks.PROXY_TYPE_SOCKS5, self.tor_proxy_host, self.tor_proxy_port, rdns=True)
+            socket.socket = socks.socksocket
+            socket.getaddrinfo = getaddrinfo_tor  # Without this accessing .onion links would fail
+
+        socket.setdefaulttimeout(timeout)
+
+    def popConnectionParameters(self) -> None:
+        if self.use_tor_proxy:
+            socket.socket = self.default_socket
+            socket.getaddrinfo = self.default_socket_getaddrinfo
+        socket.setdefaulttimeout(self.default_socket_timeout)
+
+    def readURL(self, url: str, timeout: int = 120, headers=None) -> bytes:
+        open_handler = None
+        if self.use_tor_proxy:
+            open_handler = SocksiPyHandler(socks.PROXY_TYPE_SOCKS5, self.tor_proxy_host, self.tor_proxy_port)
+        opener = urllib.request.build_opener(open_handler) if self.use_tor_proxy else urllib.request.build_opener()
+        opener.addheaders = [('User-agent', 'Mozilla/5.0')]
+        request = urllib.request.Request(url, headers=headers)
+        return opener.open(request, timeout=timeout).read()
+
+    def logException(self, message) -> None:
+        self.log.error(message)
+        if self.debug:
+            self.log.error(traceback.format_exc())
+
+    def torControl(self, query):
+        try:
+            command = 'AUTHENTICATE "{}"\r\n{}\r\nQUIT\r\n'.format(self.tor_control_password, query).encode('utf-8')
+            c = socket.create_connection((self.tor_proxy_host, self.tor_control_port))
+            c.send(command)
+            response = bytearray()
+            while True:
+                rv = c.recv(1024)
+                if not rv:
+                    break
+                response += rv
+            c.close()
+            return response
+        except Exception as e:
+            self.log.error(f'torControl {e}')
+            return
+
+    def getTime(self) -> int:
+        return int(time.time()) + self.mock_time_offset
+
+    def setMockTimeOffset(self, new_offset: int) -> None:
+        self.log.warning(f'Setting mocktime to {new_offset}')
+        self.mock_time_offset = new_offset
+
+    def get_int_setting(self, name: str, default_v: int, min_v: int, max_v) -> int:
+        value: int = self.settings.get(name, default_v)
+        if value < min_v:
+            self.log.warning(f'Setting {name} to {min_v}')
+            value = min_v
+        if value > max_v:
+            self.log.warning(f'Setting {name} to {max_v}')
+            value = max_v
+        return value
+
+    def get_delay_event_seconds(self):
+        if self.min_delay_event == self.max_delay_event:
+            return self.min_delay_event
+        return random.randrange(self.min_delay_event, self.max_delay_event)
+
+    def get_short_delay_event_seconds(self):
+        if self.min_delay_event_short == self.max_delay_event_short:
+            return self.min_delay_event_short
+        return random.randrange(self.min_delay_event_short, self.max_delay_event_short)
+
+    def get_delay_retry_seconds(self):
+        if self.min_delay_retry == self.max_delay_retry:
+            return self.min_delay_retry
+        return random.randrange(self.min_delay_retry, self.max_delay_retry)

basicswap/basicswap_util.py

@@ -1,6 +1,6 @@
 # -*- coding: utf-8 -*-
 
-# Copyright (c) 2021 tecnovert
+# Copyright (c) 2021-2023 tecnovert
 # Distributed under the MIT software license, see the accompanying
 # file LICENSE or http://www.opensource.org/licenses/mit-license.php.
 
@@ -8,7 +8,7 @@
 import struct
 import hashlib
 from enum import IntEnum, auto
-from .util import (
+from .util.address import (
     encodeAddress,
     decodeAddress,
 )
@@ -47,6 +47,9 @@ class MessageTypes(IntEnum):
     XMR_BID_LOCK_RELEASE_LF = auto()
     OFFER_REVOKE = auto()
 
+    ADS_BID_LF = auto()
+    ADS_BID_ACCEPT_FL = auto()
+
 
 class AddressTypes(IntEnum):
     OFFER = auto()
@@ -64,38 +67,42 @@ class SwapTypes(IntEnum):
 
 
 class OfferStates(IntEnum):
-    OFFER_SENT = auto()
-    OFFER_RECEIVED = auto()
-    OFFER_ABANDONED = auto()
+    OFFER_SENT = 1
+    OFFER_RECEIVED = 2
+    OFFER_ABANDONED = 3
 
 
 class BidStates(IntEnum):
-    BID_SENT = auto()
-    BID_RECEIVING = auto()          # Partially received
-    BID_RECEIVED = auto()
-    BID_RECEIVING_ACC = auto()      # Partially received accept message
-    BID_ACCEPTED = auto()           # BidAcceptMessage received/sent
-    SWAP_INITIATED = auto()         # Initiate txn validated
-    SWAP_PARTICIPATING = auto()     # Participate txn validated
-    SWAP_COMPLETED = auto()         # All swap txns spent
-    XMR_SWAP_SCRIPT_COIN_LOCKED = auto()
-    XMR_SWAP_HAVE_SCRIPT_COIN_SPEND_TX = auto()
-    XMR_SWAP_NOSCRIPT_COIN_LOCKED = auto()
-    XMR_SWAP_LOCK_RELEASED = auto()
-    XMR_SWAP_SCRIPT_TX_REDEEMED = auto()
-    XMR_SWAP_SCRIPT_TX_PREREFUND = auto()  # script txo moved into pre-refund tx
-    XMR_SWAP_NOSCRIPT_TX_REDEEMED = auto()
-    XMR_SWAP_NOSCRIPT_TX_RECOVERED = auto()
-    XMR_SWAP_FAILED_REFUNDED = auto()
-    XMR_SWAP_FAILED_SWIPED = auto()
-    XMR_SWAP_FAILED = auto()
-    SWAP_DELAYING = auto()
-    SWAP_TIMEDOUT = auto()
-    BID_ABANDONED = auto()          # Bid will no longer be processed
-    BID_ERROR = auto()              # An error occurred
-    BID_STALLED_FOR_TEST = auto()
-    BID_REJECTED = auto()
-    BID_STATE_UNKNOWN = auto()
+    BID_SENT = 1
+    BID_RECEIVING = 2               # Partially received
+    BID_RECEIVED = 3
+    BID_RECEIVING_ACC = 4           # Partially received accept message
+    BID_ACCEPTED = 5                # BidAcceptMessage received/sent
+    SWAP_INITIATED = 6              # Initiate txn validated
+    SWAP_PARTICIPATING = 7          # Participate txn validated
+    SWAP_COMPLETED = 8              # All swap txns spent
+    XMR_SWAP_SCRIPT_COIN_LOCKED = 9
+    XMR_SWAP_HAVE_SCRIPT_COIN_SPEND_TX = 10
+    XMR_SWAP_NOSCRIPT_COIN_LOCKED = 11
+    XMR_SWAP_LOCK_RELEASED = 12
+    XMR_SWAP_SCRIPT_TX_REDEEMED = 13
+    XMR_SWAP_SCRIPT_TX_PREREFUND = 14  # script txo moved into pre-refund tx
+    XMR_SWAP_NOSCRIPT_TX_REDEEMED = 15
+    XMR_SWAP_NOSCRIPT_TX_RECOVERED = 16
+    XMR_SWAP_FAILED_REFUNDED = 17
+    XMR_SWAP_FAILED_SWIPED = 18
+    XMR_SWAP_FAILED = 19
+    SWAP_DELAYING = 20
+    SWAP_TIMEDOUT = 21
+    BID_ABANDONED = 22          # Bid will no longer be processed
+    BID_ERROR = 23              # An error occurred
+    BID_STALLED_FOR_TEST = 24
+    BID_REJECTED = 25
+    BID_STATE_UNKNOWN = 26
+    XMR_SWAP_MSG_SCRIPT_LOCK_TX_SIGS = 27      # XmrBidLockTxSigsMessage
+    XMR_SWAP_MSG_SCRIPT_LOCK_SPEND_TX = 28     # XmrBidLockSpendTxMessage
+    BID_REQUEST_SENT = 29
+    BID_REQUEST_ACCEPTED = 30
 
 
 class TxStates(IntEnum):
@@ -104,6 +111,8 @@ class TxStates(IntEnum):
     TX_CONFIRMED = auto()
     TX_REDEEMED = auto()
     TX_REFUNDED = auto()
+    TX_IN_MEMPOOL = auto()
+    TX_IN_CHAIN = auto()
 
 
 class TxTypes(IntEnum):
@@ -120,9 +129,13 @@ class TxTypes(IntEnum):
     XMR_SWAP_A_LOCK_REFUND_SPEND = auto()
     XMR_SWAP_A_LOCK_REFUND_SWIPE = auto()
     XMR_SWAP_B_LOCK = auto()
+    XMR_SWAP_B_LOCK_SPEND = auto()
+    XMR_SWAP_B_LOCK_REFUND = auto()
+
+    ITX_PRE_FUNDED = auto()
 
 
-class EventTypes(IntEnum):
+class ActionTypes(IntEnum):
     ACCEPT_BID = auto()
     ACCEPT_XMR_BID = auto()
     SIGN_XMR_SWAP_LOCK_TX_A = auto()
@@ -132,6 +145,9 @@ class EventTypes(IntEnum):
     REDEEM_XMR_SWAP_LOCK_TX_A = auto()  # Follower
     REDEEM_XMR_SWAP_LOCK_TX_B = auto()  # Leader
     RECOVER_XMR_SWAP_LOCK_TX_B = auto()
+    SEND_XMR_SWAP_LOCK_SPEND_MSG = auto()
+    REDEEM_ITX = auto()
+    ACCEPT_AS_REV_BID = auto()
 
 
 class EventLogTypes(IntEnum):
@@ -155,6 +171,16 @@ class EventLogTypes(IntEnum):
     LOCK_TX_B_SPEND_TX_PUBLISHED = auto()
     LOCK_TX_A_REFUND_TX_SEEN = auto()
     LOCK_TX_A_REFUND_SPEND_TX_SEEN = auto()
+    ERROR = auto()
+    AUTOMATION_CONSTRAINT = auto()
+    AUTOMATION_ACCEPTING_BID = auto()
+    ITX_PUBLISHED = auto()
+    ITX_REDEEM_PUBLISHED = auto()
+    ITX_REFUND_PUBLISHED = auto()
+    PTX_PUBLISHED = auto()
+    PTX_REDEEM_PUBLISHED = auto()
+    PTX_REFUND_PUBLISHED = auto()
+    LOCK_TX_B_IN_MEMPOOL = auto()
 
 
 class XmrSplitMsgTypes(IntEnum):
@@ -163,12 +189,56 @@ class XmrSplitMsgTypes(IntEnum):
 
 
 class DebugTypes(IntEnum):
+    NONE = 0
     BID_STOP_AFTER_COIN_A_LOCK = auto()
     BID_DONT_SPEND_COIN_A_LOCK_REFUND = auto()
     CREATE_INVALID_COIN_B_LOCK = auto()
     BUYER_STOP_AFTER_ITX = auto()
     MAKE_INVALID_PTX = auto()
     DONT_SPEND_ITX = auto()
+    SKIP_LOCK_TX_REFUND = auto()
+    SEND_LOCKED_XMR = auto()
+    B_LOCK_TX_MISSED_SEND = auto()
+    DUPLICATE_ACTIONS = auto()
+
+
+class NotificationTypes(IntEnum):
+    NONE = 0
+    OFFER_RECEIVED = auto()
+    BID_RECEIVED = auto()
+    BID_ACCEPTED = auto()
+
+
+class AutomationOverrideOptions(IntEnum):
+    DEFAULT = 0
+    ALWAYS_ACCEPT = 1
+    NEVER_ACCEPT = auto()
+
+
+def strAutomationOverrideOption(option):
+    if option == AutomationOverrideOptions.DEFAULT:
+        return 'Default'
+    if option == AutomationOverrideOptions.ALWAYS_ACCEPT:
+        return 'Always Accept'
+    if option == AutomationOverrideOptions.NEVER_ACCEPT:
+        return 'Never Accept'
+    return 'Unknown'
+
+
+class VisibilityOverrideOptions(IntEnum):
+    DEFAULT = 0
+    HIDE = 1
+    BLOCK = auto()
+
+
+def strVisibilityOverrideOption(option):
+    if option == VisibilityOverrideOptions.DEFAULT:
+        return 'Default'
+    if option == VisibilityOverrideOptions.HIDE:
+        return 'Hide'
+    if option == VisibilityOverrideOptions.BLOCK:
+        return 'Block'
+    return 'Unknown'
 
 
 def strOfferState(state):
@@ -232,6 +302,17 @@ def strBidState(state):
         return 'Failed'
     if state == BidStates.SWAP_DELAYING:
         return 'Delaying'
+    if state == BidStates.XMR_SWAP_MSG_SCRIPT_LOCK_TX_SIGS:
+        return 'Exchanged script lock tx sigs msg'
+    if state == BidStates.XMR_SWAP_MSG_SCRIPT_LOCK_SPEND_TX:
+        return 'Exchanged script lock spend tx msg'
+    if state == BidStates.BID_REQUEST_SENT:
+        return 'Request sent'
+    if state == BidStates.BID_REQUEST_ACCEPTED:
+        return 'Request accepted'
+    if state == BidStates.BID_STATE_UNKNOWN:
+        return 'Unknown bid state'
+
     return 'Unknown' + ' ' + str(state)
 
 
@@ -246,6 +327,10 @@ def strTxState(state):
         return 'Redeemed'
     if state == TxStates.TX_REFUNDED:
         return 'Refunded'
+    if state == TxStates.TX_IN_MEMPOOL:
+        return 'In Mempool'
+    if state == TxStates.TX_IN_CHAIN:
+        return 'In Chain'
     return 'Unknown'
 
 
@@ -262,6 +347,8 @@ def strTxType(tx_type):
         return 'Chain A Lock Refund Swipe Tx'
     if tx_type == TxTypes.XMR_SWAP_B_LOCK:
         return 'Chain B Lock Tx'
+    if tx_type == TxTypes.ITX_PRE_FUNDED:
+        return 'Funded mock initiate tx'
     return 'Unknown'
 
 
@@ -289,8 +376,6 @@ def getLockName(lock_type):
 
 
 def describeEventEntry(event_type, event_msg):
-    if event_type == EventLogTypes.FAILED_TX_B_LOCK_PUBLISH:
-        return 'Failed to publish lock tx B'
     if event_type == EventLogTypes.FAILED_TX_B_LOCK_PUBLISH:
         return 'Failed to publish lock tx B'
     if event_type == EventLogTypes.LOCK_TX_A_PUBLISHED:
@@ -307,6 +392,8 @@ def describeEventEntry(event_type, event_msg):
         return 'Lock tx B seen in chain'
     if event_type == EventLogTypes.LOCK_TX_B_CONFIRMED:
         return 'Lock tx B confirmed in chain'
+    if event_type == EventLogTypes.LOCK_TX_B_IN_MEMPOOL:
+        return 'Lock tx B seen in mempool'
     if event_type == EventLogTypes.DEBUG_TWEAK_APPLIED:
         return 'Debug tweak applied ' + event_msg
     if event_type == EventLogTypes.FAILED_TX_B_REFUND:
@@ -331,11 +418,31 @@ def describeEventEntry(event_type, event_msg):
         return 'Lock tx A refund spend tx seen in chain'
     if event_type == EventLogTypes.SYSTEM_WARNING:
         return 'Warning: ' + event_msg
+    if event_type == EventLogTypes.ERROR:
+        return 'Error: ' + event_msg
+    if event_type == EventLogTypes.AUTOMATION_CONSTRAINT:
+        return 'Failed auto accepting'
+    if event_type == EventLogTypes.AUTOMATION_ACCEPTING_BID:
+        return 'Auto accepting'
+    if event_type == EventLogTypes.ITX_PUBLISHED:
+        return 'Initiate tx published'
+    if event_type == EventLogTypes.ITX_REDEEM_PUBLISHED:
+        return 'Initiate tx redeem tx published'
+    if event_type == EventLogTypes.ITX_REFUND_PUBLISHED:
+        return 'Initiate tx refund tx published'
+    if event_type == EventLogTypes.PTX_PUBLISHED:
+        return 'Participate tx published'
+    if event_type == EventLogTypes.PTX_REDEEM_PUBLISHED:
+        return 'Participate tx redeem tx published'
+    if event_type == EventLogTypes.PTX_REFUND_PUBLISHED:
+        return 'Participate tx refund tx published'
 
 
 def getVoutByAddress(txjs, p2sh):
     for o in txjs['vout']:
         try:
+            if 'address' in o['scriptPubKey'] and o['scriptPubKey']['address'] == p2sh:
+                return o['n']
             if p2sh in o['scriptPubKey']['addresses']:
                 return o['n']
         except Exception:
@@ -343,14 +450,14 @@ def getVoutByAddress(txjs, p2sh):
     raise ValueError('Address output not found in txn')
 
 
-def getVoutByP2WSH(txjs, p2wsh_hex):
+def getVoutByScriptPubKey(txjs, scriptPubKey_hex: str) -> int:
     for o in txjs['vout']:
         try:
-            if p2wsh_hex == o['scriptPubKey']['hex']:
+            if scriptPubKey_hex == o['scriptPubKey']['hex']:
                 return o['n']
         except Exception:
             pass
-    raise ValueError('P2WSH output not found in txn')
+    raise ValueError('scriptPubKey output not found in txn')
 
 
 def replaceAddrPrefix(addr, coin_type, chain_name, addr_type='pubkey_address'):
@@ -380,19 +487,62 @@ def getLastBidState(packed_states):
         return BidStates.BID_STATE_UNKNOWN
 
 
+def strSwapType(swap_type):
+    if swap_type == SwapTypes.SELLER_FIRST:
+        return 'seller_first'
+    if swap_type == SwapTypes.XMR_SWAP:
+        return 'xmr_swap'
+    return None
+
+
+def strSwapDesc(swap_type):
+    if swap_type == SwapTypes.SELLER_FIRST:
+        return 'Secret Hash'
+    if swap_type == SwapTypes.XMR_SWAP:
+        return 'Adaptor Sig'
+    return None
+
+
+inactive_states = [BidStates.SWAP_COMPLETED, BidStates.BID_ERROR, BidStates.BID_REJECTED, BidStates.SWAP_TIMEDOUT, BidStates.BID_ABANDONED]
+
+
 def isActiveBidState(state):
-    if state == BidStates.XMR_SWAP_HAVE_SCRIPT_COIN_SPEND_TX:
+    if state >= BidStates.BID_ACCEPTED and state < BidStates.SWAP_COMPLETED:
         return True
-    if state == BidStates.XMR_SWAP_SCRIPT_COIN_LOCKED:
-        return True
-    if state == BidStates.XMR_SWAP_NOSCRIPT_COIN_LOCKED:
-        return True
-    if state == BidStates.XMR_SWAP_LOCK_RELEASED:
-        return True
-    if state == BidStates.XMR_SWAP_NOSCRIPT_TX_REDEEMED:
-        return True
-    if state == BidStates.XMR_SWAP_SCRIPT_TX_REDEEMED:
-        return True
-    if state == BidStates.XMR_SWAP_SCRIPT_TX_PREREFUND:
-        return True
-    return False
+    return state in (
+        BidStates.SWAP_DELAYING,
+        BidStates.XMR_SWAP_HAVE_SCRIPT_COIN_SPEND_TX,
+        BidStates.XMR_SWAP_SCRIPT_COIN_LOCKED,
+        BidStates.XMR_SWAP_NOSCRIPT_COIN_LOCKED,
+        BidStates.XMR_SWAP_LOCK_RELEASED,
+        BidStates.XMR_SWAP_NOSCRIPT_TX_REDEEMED,
+        BidStates.XMR_SWAP_SCRIPT_TX_REDEEMED,
+        BidStates.XMR_SWAP_SCRIPT_TX_PREREFUND,
+        BidStates.XMR_SWAP_MSG_SCRIPT_LOCK_TX_SIGS,
+        BidStates.XMR_SWAP_MSG_SCRIPT_LOCK_SPEND_TX,
+        BidStates.XMR_SWAP_FAILED,
+        BidStates.BID_REQUEST_ACCEPTED,
+    )
+
+
+def isErrorBidState(state):
+    return state in (
+        BidStates.BID_STALLED_FOR_TEST,
+        BidStates.BID_ERROR,
+    )
+
+
+def isFailingBidState(state):
+    return state in (
+        BidStates.BID_STALLED_FOR_TEST,
+        BidStates.BID_ERROR,
+        BidStates.XMR_SWAP_SCRIPT_TX_PREREFUND,
+        BidStates.XMR_SWAP_NOSCRIPT_TX_RECOVERED,
+        BidStates.XMR_SWAP_FAILED_REFUNDED,
+        BidStates.XMR_SWAP_FAILED_SWIPED,
+        BidStates.XMR_SWAP_FAILED,
+    )
+
+
+def isFinalBidState(state):
+    return state in inactive_states

basicswap/chainparams.py

@@ -1,6 +1,6 @@
 # -*- coding: utf-8 -*-
 
-# Copyright (c) 2019-2021 tecnovert
+# Copyright (c) 2019-2023 tecnovert
 # Distributed under the MIT software license, see the accompanying
 # file LICENSE or http://www.opensource.org/licenses/mit-license.php.
 
@@ -26,6 +26,13 @@ class Coins(IntEnum):
     XMR = 6
     PART_BLIND = 7
     PART_ANON = 8
+    # ZANO = 9
+    # NDAU = 10
+    PIVX = 11
+    DASH = 12
+    FIRO = 13
+    NAV = 14
+    LTC_MWEB = 15
 
 
 chainparams = {
@@ -116,7 +123,8 @@ chainparams = {
         'mainnet': {
             'rpcport': 9332,
             'pubkey_address': 48,
-            'script_address': 50,
+            'script_address': 5,
+            'script_address2': 50,
             'key_prefix': 176,
             'hrp': 'ltc',
             'bip44': 2,
@@ -126,7 +134,8 @@ chainparams = {
         'testnet': {
             'rpcport': 19332,
             'pubkey_address': 111,
-            'script_address': 58,
+            'script_address': 196,
+            'script_address2': 58,
             'key_prefix': 239,
             'hrp': 'tltc',
             'bip44': 1,
@@ -137,7 +146,8 @@ chainparams = {
         'regtest': {
             'rpcport': 19443,
             'pubkey_address': 111,
-            'script_address': 58,
+            'script_address': 196,
+            'script_address2': 58,
             'key_prefix': 239,
             'hrp': 'rltc',
             'bip44': 1,
@@ -203,8 +213,177 @@ chainparams = {
             'min_amount': 100000,
             'max_amount': 10000 * XMR_COIN,
         }
+    },
+    Coins.PIVX: {
+        'name': 'pivx',
+        'ticker': 'PIVX',
+        'message_magic': 'DarkNet Signed Message:\n',
+        'blocks_target': 60 * 1,
+        'decimal_places': 8,
+        'has_cltv': True,
+        'has_csv': False,
+        'has_segwit': False,
+        'use_ticker_as_name': True,
+        'mainnet': {
+            'rpcport': 51473,
+            'pubkey_address': 30,
+            'script_address': 13,
+            'key_prefix': 212,
+            'bip44': 119,
+            'min_amount': 1000,
+            'max_amount': 100000 * COIN,
+        },
+        'testnet': {
+            'rpcport': 51475,
+            'pubkey_address': 139,
+            'script_address': 19,
+            'key_prefix': 239,
+            'bip44': 1,
+            'min_amount': 1000,
+            'max_amount': 100000 * COIN,
+            'name': 'testnet4',
+        },
+        'regtest': {
+            'rpcport': 51477,
+            'pubkey_address': 139,
+            'script_address': 19,
+            'key_prefix': 239,
+            'bip44': 1,
+            'min_amount': 1000,
+            'max_amount': 100000 * COIN,
+        }
+    },
+    Coins.DASH: {
+        'name': 'dash',
+        'ticker': 'DASH',
+        'message_magic': 'DarkCoin Signed Message:\n',
+        'blocks_target': 60 * 2.5,
+        'decimal_places': 8,
+        'has_csv': True,
+        'has_segwit': False,
+        'mainnet': {
+            'rpcport': 9998,
+            'pubkey_address': 76,
+            'script_address': 16,
+            'key_prefix': 204,
+            'hrp': '',
+            'bip44': 5,
+            'min_amount': 1000,
+            'max_amount': 100000 * COIN,
+        },
+        'testnet': {
+            'rpcport': 19998,
+            'pubkey_address': 140,
+            'script_address': 19,
+            'key_prefix': 239,
+            'hrp': '',
+            'bip44': 1,
+            'min_amount': 1000,
+            'max_amount': 100000 * COIN,
+        },
+        'regtest': {
+            'rpcport': 18332,
+            'pubkey_address': 140,
+            'script_address': 19,
+            'key_prefix': 239,
+            'hrp': '',
+            'bip44': 1,
+            'min_amount': 1000,
+            'max_amount': 100000 * COIN,
+        }
+    },
+    Coins.FIRO: {
+        'name': 'firo',
+        'ticker': 'FIRO',
+        'message_magic': 'Zcoin Signed Message:\n',
+        'blocks_target': 60 * 10,
+        'decimal_places': 8,
+        'has_cltv': False,
+        'has_csv': False,
+        'has_segwit': False,
+        'mainnet': {
+            'rpcport': 8888,
+            'pubkey_address': 82,
+            'script_address': 7,
+            'key_prefix': 210,
+            'hrp': '',
+            'bip44': 136,
+            'min_amount': 1000,
+            'max_amount': 100000 * COIN,
+        },
+        'testnet': {
+            'rpcport': 18888,
+            'pubkey_address': 65,
+            'script_address': 178,
+            'key_prefix': 185,
+            'hrp': '',
+            'bip44': 1,
+            'min_amount': 1000,
+            'max_amount': 100000 * COIN,
+        },
+        'regtest': {
+            'rpcport': 28888,
+            'pubkey_address': 65,
+            'script_address': 178,
+            'key_prefix': 239,
+            'hrp': '',
+            'bip44': 1,
+            'min_amount': 1000,
+            'max_amount': 100000 * COIN,
+        }
+    },
+    Coins.NAV: {
+        'name': 'navcoin',
+        'ticker': 'NAV',
+        'message_magic': 'Navcoin Signed Message:\n',
+        'blocks_target': 30,
+        'decimal_places': 8,
+        'has_csv': True,
+        'has_segwit': True,
+        'mainnet': {
+            'rpcport': 44444,
+            'pubkey_address': 53,
+            'script_address': 85,
+            'key_prefix': 150,
+            'hrp': '',
+            'bip44': 130,
+            'min_amount': 1000,
+            'max_amount': 100000 * COIN,
+        },
+        'testnet': {
+            'rpcport': 44445,
+            'pubkey_address': 111,
+            'script_address': 196,
+            'key_prefix': 239,
+            'hrp': '',
+            'bip44': 1,
+            'min_amount': 1000,
+            'max_amount': 100000 * COIN,
+        },
+        'regtest': {
+            'rpcport': 44446,
+            'pubkey_address': 111,
+            'script_address': 196,
+            'key_prefix': 239,
+            'hrp': '',
+            'bip44': 1,
+            'min_amount': 1000,
+            'max_amount': 100000 * COIN,
+        }
     }
 }
+ticker_map = {}
+
+
+for c, params in chainparams.items():
+    ticker_map[params['ticker'].lower()] = c
+
+
+def getCoinIdFromTicker(ticker):
+    try:
+        return ticker_map[ticker.lower()]
+    except Exception:
+        raise ValueError('Unknown coin')
 
 
 class CoinInterface:
@@ -217,17 +396,20 @@ class CoinInterface:
         self._unknown_wallet_seed = True
         self._restore_height = None
 
-    def make_int(self, amount_in, r=0):
+    def make_int(self, amount_in: int, r: int = 0) -> int:
         return make_int(amount_in, self.exp(), r=r)
 
     def format_amount(self, amount_in, conv_int=False, r=0):
         amount_int = make_int(amount_in, self.exp(), r=r) if conv_int else amount_in
         return format_amount(amount_int, self.exp())
 
-    def coin_name(self):
-        return chainparams[self.coin_type()]['name'].capitalize()
+    def coin_name(self) -> str:
+        coin_chainparams = chainparams[self.coin_type()]
+        if coin_chainparams.get('use_ticker_as_name', False):
+            return coin_chainparams['ticker']
+        return coin_chainparams['name'].capitalize()
 
-    def ticker(self):
+    def ticker(self) -> str:
         ticker = chainparams[self.coin_type()]['ticker']
         if self._network == 'testnet':
             ticker = 't' + ticker
@@ -235,19 +417,29 @@ class CoinInterface:
             ticker = 'rt' + ticker
         return ticker
 
-    def min_amount(self):
+    def getExchangeTicker(self, exchange_name: str) -> str:
+        return chainparams[self.coin_type()]['ticker']
+
+    def getExchangeName(self, exchange_name: str) -> str:
+        return chainparams[self.coin_type()]['name']
+
+    def ticker_mainnet(self) -> str:
+        ticker = chainparams[self.coin_type()]['ticker']
+        return ticker
+
+    def min_amount(self) -> int:
         return chainparams[self.coin_type()][self._network]['min_amount']
 
-    def max_amount(self):
+    def max_amount(self) -> int:
         return chainparams[self.coin_type()][self._network]['max_amount']
 
-    def setWalletSeedWarning(self, value):
+    def setWalletSeedWarning(self, value: bool) -> None:
         self._unknown_wallet_seed = value
 
-    def setWalletRestoreHeight(self, value):
+    def setWalletRestoreHeight(self, value: int) -> None:
         self._restore_height = value
 
-    def knownWalletSeed(self):
+    def knownWalletSeed(self) -> bool:
         return not self._unknown_wallet_seed
 
     def chainparams(self):
@@ -256,16 +448,25 @@ class CoinInterface:
     def chainparams_network(self):
         return chainparams[self.coin_type()][self._network]
 
-    def is_transient_error(self, ex):
+    def has_segwit(self) -> bool:
+        return chainparams[self.coin_type()].get('has_segwit', True)
+
+    def is_transient_error(self, ex) -> bool:
         if isinstance(ex, TemporaryError):
             return True
-        str_error = str(ex).lower()
+        str_error: str = str(ex).lower()
         if 'not enough unlocked money' in str_error:
             return True
+        if 'no unlocked balance' in str_error:
+            return True
         if 'transaction was rejected by daemon' in str_error:
             return True
         if 'invalid unlocked_balance' in str_error:
             return True
         if 'daemon is busy' in str_error:
             return True
+        if 'timed out' in str_error:
+            return True
+        if 'request-sent' in str_error:
+            return True
         return False

basicswap/config.py

@@ -1,16 +1,16 @@
 # -*- coding: utf-8 -*-
 
-# Copyright (c) 2019 tecnovert
+# Copyright (c) 2019-2023 tecnovert
 # Distributed under the MIT software license, see the accompanying
 # file LICENSE or http://www.opensource.org/licenses/mit-license.php.
 
 import os
 
 CONFIG_FILENAME = 'basicswap.json'
-DEFAULT_DATADIR = '~/.basicswap'
+BASICSWAP_DATADIR = os.getenv('BASICSWAP_DATADIR', '~/.basicswap')
 DEFAULT_ALLOW_CORS = False
 TEST_DATADIRS = os.path.expanduser(os.getenv('DATADIRS', '/tmp/basicswap'))
-DEFAULT_TEST_BINDIR = os.path.expanduser(os.getenv('DEFAULT_TEST_BINDIR', '~/tmp/bin'))
+DEFAULT_TEST_BINDIR = os.path.expanduser(os.getenv('DEFAULT_TEST_BINDIR', '~/.basicswap/bin'))
 
 bin_suffix = ('.exe' if os.name == 'nt' else '')
 PARTICL_BINDIR = os.path.expanduser(os.getenv('PARTICL_BINDIR', os.path.join(DEFAULT_TEST_BINDIR, 'particl')))

basicswap/contrib/test_framework/script.py

@@ -10,6 +10,7 @@ import hashlib
 import struct
 import unittest
 from typing import List, Dict
+from basicswap.util.crypto import ripemd160
 
 from .messages import (
     CTransaction,
@@ -25,7 +26,7 @@ MAX_SCRIPT_ELEMENT_SIZE = 520
 OPCODE_NAMES = {}  # type: Dict[CScriptOp, str]
 
 def hash160(s):
-    return hashlib.new('ripemd160', sha256(s)).digest()
+    return ripemd160(sha256(s))
 
 def bn2vch(v):
     """Convert number to bitcoin-specific little endian format."""

basicswap/contrib/test_framework/util.py

@@ -614,6 +614,11 @@ def find_vout_for_address(node, txid, addr):
     """
     tx = node.getrawtransaction(txid, True)
     for i in range(len(tx["vout"])):
-        if any([addr == a for a in tx["vout"][i]["scriptPubKey"]["addresses"]]):
-            return i
+        scriptPubKey = tx["vout"][i]["scriptPubKey"]
+        if "addresses" in scriptPubKey:
+            if any([addr == a for a in scriptPubKey["addresses"]]):
+                return i
+        elif "address" in scriptPubKey:
+            if addr == scriptPubKey["address"]:
+                return i
     raise RuntimeError("Vout not found for address: txid=%s, addr=%s" % (txid, addr))

basicswap/contrib/websocket_server/__init__.py

@@ -0,0 +1 @@
+from .websocket_server import *

basicswap/contrib/websocket_server/thread.py

@@ -0,0 +1,38 @@
+import threading
+
+
+class ThreadWithLoggedException(threading.Thread):
+    """
+    Similar to Thread but will log exceptions to passed logger.
+
+    Args:
+        logger: Logger instance used to log any exception in child thread
+
+    Exception is also reachable via <thread>.exception from the main thread.
+    """
+
+    DIVIDER = "*"*80
+
+    def __init__(self, *args, **kwargs):
+        try:
+            self.logger = kwargs.pop("logger")
+        except KeyError:
+            raise Exception("Missing 'logger' in kwargs")
+        super().__init__(*args, **kwargs)
+        self.exception = None
+
+    def run(self):
+        try:
+            if self._target is not None:
+                self._target(*self._args, **self._kwargs)
+        except Exception as exception:
+            thread = threading.current_thread()
+            self.exception = exception
+            self.logger.exception(f"{self.DIVIDER}\nException in child thread {thread}: {exception}\n{self.DIVIDER}")
+        finally:
+            del self._target, self._args, self._kwargs
+
+
+class WebsocketServerThread(ThreadWithLoggedException):
+    """Dummy wrapper to make debug messages a bit more readable"""
+    pass

basicswap/contrib/websocket_server/websocket_server.py

@@ -0,0 +1,495 @@
+# Author: Johan Hanssen Seferidis
+# License: MIT
+
+import sys
+import struct
+import ssl
+from base64 import b64encode
+from hashlib import sha1
+import logging
+from socket import error as SocketError
+import errno
+import threading
+from socketserver import ThreadingMixIn, TCPServer, StreamRequestHandler
+
+from .thread import WebsocketServerThread
+
+logger = logging.getLogger(__name__)
+logging.basicConfig()
+
+'''
++-+-+-+-+-------+-+-------------+-------------------------------+
+ 0                   1                   2                   3
+ 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
++-+-+-+-+-------+-+-------------+-------------------------------+
+|F|R|R|R| opcode|M| Payload len |    Extended payload length    |
+|I|S|S|S|  (4)  |A|     (7)     |             (16/64)           |
+|N|V|V|V|       |S|             |   (if payload len==126/127)   |
+| |1|2|3|       |K|             |                               |
++-+-+-+-+-------+-+-------------+ - - - - - - - - - - - - - - - +
+|     Extended payload length continued, if payload len == 127  |
++ - - - - - - - - - - - - - - - +-------------------------------+
+|                     Payload Data continued ...                |
++---------------------------------------------------------------+
+'''
+
+FIN    = 0x80
+OPCODE = 0x0f
+MASKED = 0x80
+PAYLOAD_LEN = 0x7f
+PAYLOAD_LEN_EXT16 = 0x7e
+PAYLOAD_LEN_EXT64 = 0x7f
+
+OPCODE_CONTINUATION = 0x0
+OPCODE_TEXT         = 0x1
+OPCODE_BINARY       = 0x2
+OPCODE_CLOSE_CONN   = 0x8
+OPCODE_PING         = 0x9
+OPCODE_PONG         = 0xA
+
+CLOSE_STATUS_NORMAL = 1000
+DEFAULT_CLOSE_REASON = bytes('', encoding='utf-8')
+
+
+class API():
+
+    def run_forever(self, threaded=False):
+        return self._run_forever(threaded)
+
+    def new_client(self, client, server):
+        pass
+
+    def client_left(self, client, server):
+        pass
+
+    def message_received(self, client, server, message):
+        pass
+
+    def set_fn_new_client(self, fn):
+        self.new_client = fn
+
+    def set_fn_client_left(self, fn):
+        self.client_left = fn
+
+    def set_fn_message_received(self, fn):
+        self.message_received = fn
+
+    def send_message(self, client, msg):
+        self._unicast(client, msg)
+
+    def send_message_to_all(self, msg):
+        self._multicast(msg)
+
+    def deny_new_connections(self, status=CLOSE_STATUS_NORMAL, reason=DEFAULT_CLOSE_REASON):
+        self._deny_new_connections(status, reason)
+
+    def allow_new_connections(self):
+        self._allow_new_connections()
+
+    def shutdown_gracefully(self, status=CLOSE_STATUS_NORMAL, reason=DEFAULT_CLOSE_REASON):
+        self._shutdown_gracefully(status, reason)
+
+    def shutdown_abruptly(self):
+        self._shutdown_abruptly()
+
+    def disconnect_clients_gracefully(self, status=CLOSE_STATUS_NORMAL, reason=DEFAULT_CLOSE_REASON):
+        self._disconnect_clients_gracefully(status, reason)
+
+    def disconnect_clients_abruptly(self):
+        self._disconnect_clients_abruptly()
+
+
+class WebsocketServer(ThreadingMixIn, TCPServer, API):
+    """
+    A websocket server waiting for clients to connect.
+
+    Args:
+        port(int): Port to bind to
+        host(str): Hostname or IP to listen for connections. By default 127.0.0.1
+            is being used. To accept connections from any client, you should use
+            0.0.0.0.
+        loglevel: Logging level from logging module to use for logging. By default
+            warnings and errors are being logged.
+
+    Properties:
+        clients(list): A list of connected clients. A client is a dictionary
+            like below.
+                {
+                 'id'      : id,
+                 'handler' : handler,
+                 'address' : (addr, port)
+                }
+    """
+
+    allow_reuse_address = True
+    daemon_threads = True  # comment to keep threads alive until finished
+
+    def __init__(self, host='127.0.0.1', port=0, loglevel=logging.WARNING, key=None, cert=None):
+        logger.setLevel(loglevel)
+        TCPServer.__init__(self, (host, port), WebSocketHandler)
+        self.host = host
+        self.port = self.socket.getsockname()[1]
+        self.url = f'ws://{self.host}:{self.port}/'
+
+        self.key = key
+        self.cert = cert
+
+        self.clients = []
+        self.id_counter = 0
+        self.thread = None
+
+        self._deny_clients = False
+
+    def _run_forever(self, threaded):
+        cls_name = self.__class__.__name__
+        try:
+            logger.info("Listening on port %d for clients.." % self.port)
+            if threaded:
+                self.daemon = True
+                self.thread = WebsocketServerThread(target=super().serve_forever, daemon=True, logger=logger)
+                if sys.version_info[0] > 3 or (sys.version_info[0] == 3 and sys.version_info[1] >= 10):
+                    logger.info(f"Starting {cls_name} on thread {self.thread.name}.")
+                else:
+                    logger.info(f"Starting {cls_name} on thread {self.thread.getName()}.")
+                self.thread.start()
+            else:
+                self.thread = threading.current_thread()
+                logger.info(f"Starting {cls_name} on main thread.")
+                super().serve_forever()
+        except KeyboardInterrupt:
+            self.server_close()
+            logger.info("Server terminated.")
+        except Exception as e:
+            logger.error(str(e), exc_info=True)
+            sys.exit(1)
+
+    def _message_received_(self, handler, msg):
+        self.message_received(self.handler_to_client(handler), self, msg)
+
+    def _ping_received_(self, handler, msg):
+        handler.send_pong(msg)
+
+    def _pong_received_(self, handler, msg):
+        pass
+
+    def _new_client_(self, handler):
+        if self._deny_clients:
+            status = self._deny_clients["status"]
+            reason = self._deny_clients["reason"]
+            handler.send_close(status, reason)
+            self._terminate_client_handler(handler)
+            return
+
+        self.id_counter += 1
+        client = {
+            'id': self.id_counter,
+            'handler': handler,
+            'address': handler.client_address
+        }
+        self.clients.append(client)
+        self.new_client(client, self)
+
+    def _client_left_(self, handler):
+        client = self.handler_to_client(handler)
+        self.client_left(client, self)
+        if client in self.clients:
+            self.clients.remove(client)
+
+    def _unicast(self, receiver_client, msg):
+        receiver_client['handler'].send_message(msg)
+
+    def _multicast(self, msg):
+        for client in self.clients:
+            self._unicast(client, msg)
+
+    def handler_to_client(self, handler):
+        for client in self.clients:
+            if client['handler'] == handler:
+                return client
+
+    def _terminate_client_handler(self, handler):
+        handler.keep_alive = False
+        handler.finish()
+        handler.connection.close()
+
+    def _terminate_client_handlers(self):
+        """
+        Ensures request handler for each client is terminated correctly
+        """
+        for client in self.clients:
+            self._terminate_client_handler(client["handler"])
+
+    def _shutdown_gracefully(self, status=CLOSE_STATUS_NORMAL, reason=DEFAULT_CLOSE_REASON):
+        """
+        Send a CLOSE handshake to all connected clients before terminating server
+        """
+        self.keep_alive = False
+        self._disconnect_clients_gracefully(status, reason)
+        self.server_close()
+        self.shutdown()
+
+    def _shutdown_abruptly(self):
+        """
+        Terminate server without sending a CLOSE handshake
+        """
+        self.keep_alive = False
+        self._disconnect_clients_abruptly()
+        self.server_close()
+        self.shutdown()
+
+    def _disconnect_clients_gracefully(self, status=CLOSE_STATUS_NORMAL, reason=DEFAULT_CLOSE_REASON):
+        """
+        Terminate clients gracefully without shutting down the server
+        """
+        for client in self.clients:
+            client["handler"].send_close(status, reason)
+        self._terminate_client_handlers()
+
+    def _disconnect_clients_abruptly(self):
+        """
+        Terminate clients abruptly (no CLOSE handshake) without shutting down the server
+        """
+        self._terminate_client_handlers()
+
+    def _deny_new_connections(self, status, reason):
+        self._deny_clients = {
+            "status": status,
+            "reason": reason,
+        }
+
+    def _allow_new_connections(self):
+        self._deny_clients = False
+
+
+class WebSocketHandler(StreamRequestHandler):
+
+    def __init__(self, socket, addr, server):
+        self.server = server
+        self.timeout = 1000  # Must set a timeout or rfile.read timesout in the tests
+        assert not hasattr(self, "_send_lock"), "_send_lock already exists"
+        self._send_lock = threading.Lock()
+        if server.key and server.cert:
+            try:
+                socket = ssl.wrap_socket(socket, server_side=True, certfile=server.cert, keyfile=server.key)
+            except: # Not sure which exception it throws if the key/cert isn't found
+                logger.warning("SSL not available (are the paths {} and {} correct for the key and cert?)".format(server.key, server.cert))
+        StreamRequestHandler.__init__(self, socket, addr, server)
+
+    def setup(self):
+        StreamRequestHandler.setup(self)
+        self.keep_alive = True
+        self.handshake_done = False
+        self.valid_client = False
+
+    def handle(self):
+        while self.keep_alive:
+            if not self.handshake_done:
+                self.handshake()
+            elif self.valid_client:
+                self.read_next_message()
+
+    def read_bytes(self, num):
+        return self.rfile.read(num)
+
+    def read_next_message(self):
+        try:
+            b1, b2 = self.read_bytes(2)
+        except TimeoutError:
+            return
+        except SocketError as e:  # to be replaced with ConnectionResetError for py3
+            if e.errno == errno.ECONNRESET:
+                logger.info("Client closed connection.")
+                self.keep_alive = 0
+                return
+            b1, b2 = 0, 0
+        except ValueError as e:
+            b1, b2 = 0, 0
+
+        fin    = b1 & FIN
+        opcode = b1 & OPCODE
+        masked = b2 & MASKED
+        payload_length = b2 & PAYLOAD_LEN
+
+        if opcode == OPCODE_CLOSE_CONN:
+            logger.info("Client asked to close connection.")
+            self.keep_alive = 0
+            return
+        if not masked:
+            logger.warning("Client must always be masked.")
+            self.keep_alive = 0
+            return
+        if opcode == OPCODE_CONTINUATION:
+            logger.warning("Continuation frames are not supported.")
+            return
+        elif opcode == OPCODE_BINARY:
+            logger.warning("Binary frames are not supported.")
+            return
+        elif opcode == OPCODE_TEXT:
+            opcode_handler = self.server._message_received_
+        elif opcode == OPCODE_PING:
+            opcode_handler = self.server._ping_received_
+        elif opcode == OPCODE_PONG:
+            opcode_handler = self.server._pong_received_
+        else:
+            logger.warning("Unknown opcode %#x." % opcode)
+            self.keep_alive = 0
+            return
+
+        if payload_length == 126:
+            payload_length = struct.unpack(">H", self.rfile.read(2))[0]
+        elif payload_length == 127:
+            payload_length = struct.unpack(">Q", self.rfile.read(8))[0]
+
+        masks = self.read_bytes(4)
+        message_bytes = bytearray()
+        for message_byte in self.read_bytes(payload_length):
+            message_byte ^= masks[len(message_bytes) % 4]
+            message_bytes.append(message_byte)
+        opcode_handler(self, message_bytes.decode('utf8'))
+
+    def send_message(self, message):
+        self.send_text(message)
+
+    def send_pong(self, message):
+        self.send_text(message, OPCODE_PONG)
+
+    def send_close(self, status=CLOSE_STATUS_NORMAL, reason=DEFAULT_CLOSE_REASON):
+        """
+        Send CLOSE to client
+
+        Args:
+            status: Status as defined in https://datatracker.ietf.org/doc/html/rfc6455#section-7.4.1
+            reason: Text with reason of closing the connection
+        """
+        if status < CLOSE_STATUS_NORMAL or status > 1015:
+            raise Exception(f"CLOSE status must be between 1000 and 1015, got {status}")
+
+        header = bytearray()
+        payload = struct.pack('!H', status) + reason
+        payload_length = len(payload)
+        assert payload_length <= 125, "We only support short closing reasons at the moment"
+
+        # Send CLOSE with status & reason
+        header.append(FIN | OPCODE_CLOSE_CONN)
+        header.append(payload_length)
+        with self._send_lock:
+            self.request.send(header + payload)
+
+    def send_text(self, message, opcode=OPCODE_TEXT):
+        """
+        Important: Fragmented(=continuation) messages are not supported since
+        their usage cases are limited - when we don't know the payload length.
+        """
+
+        # Validate message
+        if isinstance(message, bytes):
+            message = try_decode_UTF8(message)  # this is slower but ensures we have UTF-8
+            if not message:
+                logger.warning("Can\'t send message, message is not valid UTF-8")
+                return False
+        elif not isinstance(message, str):
+            logger.warning('Can\'t send message, message has to be a string or bytes. Got %s' % type(message))
+            return False
+
+        header  = bytearray()
+        payload = encode_to_UTF8(message)
+        payload_length = len(payload)
+
+        # Normal payload
+        if payload_length <= 125:
+            header.append(FIN | opcode)
+            header.append(payload_length)
+
+        # Extended payload
+        elif payload_length >= 126 and payload_length <= 65535:
+            header.append(FIN | opcode)
+            header.append(PAYLOAD_LEN_EXT16)
+            header.extend(struct.pack(">H", payload_length))
+
+        # Huge extended payload
+        elif payload_length < 18446744073709551616:
+            header.append(FIN | opcode)
+            header.append(PAYLOAD_LEN_EXT64)
+            header.extend(struct.pack(">Q", payload_length))
+
+        else:
+            raise Exception("Message is too big. Consider breaking it into chunks.")
+            return
+
+        with self._send_lock:
+            self.request.send(header + payload)
+
+    def read_http_headers(self):
+        headers = {}
+        # first line should be HTTP GET
+        http_get = self.rfile.readline().decode().strip()
+        assert http_get.upper().startswith('GET')
+        # remaining should be headers
+        while True:
+            header = self.rfile.readline().decode().strip()
+            if not header:
+                break
+            head, value = header.split(':', 1)
+            headers[head.lower().strip()] = value.strip()
+        return headers
+
+    def handshake(self):
+        headers = self.read_http_headers()
+
+        try:
+            assert headers['upgrade'].lower() == 'websocket'
+        except AssertionError:
+            self.keep_alive = False
+            return
+
+        try:
+            key = headers['sec-websocket-key']
+        except KeyError:
+            logger.warning("Client tried to connect but was missing a key")
+            self.keep_alive = False
+            return
+
+        response = self.make_handshake_response(key)
+        with self._send_lock:
+            self.handshake_done = self.request.send(response.encode())
+        self.valid_client = True
+        self.server._new_client_(self)
+
+    @classmethod
+    def make_handshake_response(cls, key):
+        return \
+          'HTTP/1.1 101 Switching Protocols\r\n'\
+          'Upgrade: websocket\r\n'              \
+          'Connection: Upgrade\r\n'             \
+          'Sec-WebSocket-Accept: %s\r\n'        \
+          '\r\n' % cls.calculate_response_key(key)
+
+    @classmethod
+    def calculate_response_key(cls, key):
+        GUID = '258EAFA5-E914-47DA-95CA-C5AB0DC85B11'
+        hash = sha1(key.encode() + GUID.encode())
+        response_key = b64encode(hash.digest()).strip()
+        return response_key.decode('ASCII')
+
+    def finish(self):
+        self.server._client_left_(self)
+
+
+def encode_to_UTF8(data):
+    try:
+        return data.encode('UTF-8')
+    except UnicodeEncodeError as e:
+        logger.error("Could not encode data to UTF-8 -- %s" % e)
+        return False
+    except Exception as e:
+        raise(e)
+        return False
+
+
+def try_decode_UTF8(data):
+    try:
+        return data.decode('utf-8')
+    except UnicodeDecodeError:
+        return False
+    except Exception as e:
+        raise(e)

basicswap/db.py

@@ -1,6 +1,6 @@
 # -*- coding: utf-8 -*-
 
-# Copyright (c) 2019-2021 tecnovert
+# Copyright (c) 2019-2023 tecnovert
 # Distributed under the MIT software license, see the accompanying
 # file LICENSE or http://www.opensource.org/licenses/mit-license.php.
 
@@ -12,13 +12,26 @@ from enum import IntEnum, auto
 from sqlalchemy.ext.declarative import declarative_base
 
 
-CURRENT_DB_VERSION = 13
+CURRENT_DB_VERSION = 22
+CURRENT_DB_DATA_VERSION = 4
 Base = declarative_base()
 
 
-class TableTypes(IntEnum):
+class Concepts(IntEnum):
     OFFER = auto()
     BID = auto()
+    NETWORK_MESSAGE = auto()
+    AUTOMATION = auto()
+
+
+def strConcepts(state):
+    if state == Concepts.OFFER:
+        return 'Offer'
+    if state == Concepts.BID:
+        return 'Bid'
+    if state == Concepts.NETWORK_MESSAGE:
+        return 'Network Message'
+    return 'Unknown'
 
 
 class DBKVInt(Base):
@@ -54,6 +67,7 @@ class Offer(Base):
 
     proof_address = sa.Column(sa.String)
     proof_signature = sa.Column(sa.LargeBinary)
+    proof_utxos = sa.Column(sa.LargeBinary)
     pkhash_seller = sa.Column(sa.LargeBinary)
     secret_hash = sa.Column(sa.LargeBinary)
 
@@ -61,7 +75,7 @@ class Offer(Base):
     addr_to = sa.Column(sa.String)
     created_at = sa.Column(sa.BigInteger)
     expire_at = sa.Column(sa.BigInteger)
-    was_sent = sa.Column(sa.Boolean)
+    was_sent = sa.Column(sa.Boolean)  # Sent by node
 
     from_feerate = sa.Column(sa.BigInteger)
     to_feerate = sa.Column(sa.BigInteger)
@@ -73,6 +87,7 @@ class Offer(Base):
     auto_accept_bids = sa.Column(sa.Boolean)
     withdraw_to_addr = sa.Column(sa.String)  # Address to spend lock tx to - address from wallet if empty TODO
     security_token = sa.Column(sa.LargeBinary)
+    bid_reversed = sa.Column(sa.Boolean)
 
     state = sa.Column(sa.Integer)
     states = sa.Column(sa.LargeBinary)  # Packed states and times
@@ -94,13 +109,14 @@ class Bid(Base):
     active_ind = sa.Column(sa.Integer)
 
     protocol_version = sa.Column(sa.Integer)
-    was_sent = sa.Column(sa.Boolean)
+    was_sent = sa.Column(sa.Boolean)  # Sent by node
     was_received = sa.Column(sa.Boolean)
     contract_count = sa.Column(sa.Integer)
     created_at = sa.Column(sa.BigInteger)
     expire_at = sa.Column(sa.BigInteger)
     bid_addr = sa.Column(sa.String)
     proof_address = sa.Column(sa.String)
+    proof_utxos = sa.Column(sa.LargeBinary)
     withdraw_to_addr = sa.Column(sa.String)  # Address to spend lock tx to - address from wallet if empty TODO
 
     recovered_secret = sa.Column(sa.LargeBinary)
@@ -110,7 +126,6 @@ class Bid(Base):
     amount = sa.Column(sa.BigInteger)
     rate = sa.Column(sa.BigInteger)
 
-    accept_msg_id = sa.Column(sa.LargeBinary)
     pkhash_seller = sa.Column(sa.LargeBinary)
 
     initiate_txn_redeem = sa.Column(sa.LargeBinary)
@@ -204,10 +219,25 @@ class SwapTx(Base):
     states = sa.Column(sa.LargeBinary)  # Packed states and times
 
     def setState(self, new_state):
+        if self.state == new_state:
+            return
         self.state = new_state
         self.states = (self.states if self.states is not None else bytes()) + struct.pack('<iq', new_state, int(time.time()))
 
 
+class PrefundedTx(Base):
+    __tablename__ = 'prefunded_transactions'
+
+    record_id = sa.Column(sa.Integer, primary_key=True, autoincrement=True)
+    active_ind = sa.Column(sa.Integer)
+    created_at = sa.Column(sa.BigInteger)
+    linked_type = sa.Column(sa.Integer)
+    linked_id = sa.Column(sa.LargeBinary)
+    tx_type = sa.Column(sa.Integer)  # TxTypes
+    tx_data = sa.Column(sa.LargeBinary)
+    used_by = sa.Column(sa.LargeBinary)
+
+
 class PooledAddress(Base):
     __tablename__ = 'addresspool'
 
@@ -236,16 +266,16 @@ class SmsgAddress(Base):
     note = sa.Column(sa.String)
 
 
-class EventQueue(Base):
-    __tablename__ = 'eventqueue'
+class Action(Base):
+    __tablename__ = 'actions'
 
-    event_id = sa.Column(sa.Integer, primary_key=True, autoincrement=True)
+    action_id = sa.Column(sa.Integer, primary_key=True, autoincrement=True)
     active_ind = sa.Column(sa.Integer)
     created_at = sa.Column(sa.BigInteger)
     trigger_at = sa.Column(sa.BigInteger)
     linked_id = sa.Column(sa.LargeBinary)
-    event_type = sa.Column(sa.Integer)
-    event_data = sa.Column(sa.LargeBinary)
+    action_type = sa.Column(sa.Integer)
+    action_data = sa.Column(sa.LargeBinary)
 
 
 class EventLog(Base):
@@ -264,12 +294,13 @@ class EventLog(Base):
 
 class XmrOffer(Base):
     __tablename__ = 'xmr_offers'
+    # TODO: Merge to Offer
 
     swap_id = sa.Column(sa.Integer, primary_key=True, autoincrement=True)
     offer_id = sa.Column(sa.LargeBinary, sa.ForeignKey('offers.offer_id'))
 
-    a_fee_rate = sa.Column(sa.BigInteger)
-    b_fee_rate = sa.Column(sa.BigInteger)
+    a_fee_rate = sa.Column(sa.BigInteger)  # Chain a fee rate
+    b_fee_rate = sa.Column(sa.BigInteger)  # Chain b fee rate
 
     lock_time_1 = sa.Column(sa.Integer)  # Delay before the chain a lock refund tx can be mined
     lock_time_2 = sa.Column(sa.Integer)  # Delay before the follower can spend from the chain a lock refund tx
@@ -280,15 +311,6 @@ class XmrSwap(Base):
 
     swap_id = sa.Column(sa.Integer, primary_key=True, autoincrement=True)
     bid_id = sa.Column(sa.LargeBinary, sa.ForeignKey('bids.bid_id'))
-    bid_msg_id2 = sa.Column(sa.LargeBinary)
-    bid_msg_id3 = sa.Column(sa.LargeBinary)
-
-    bid_accept_msg_id = sa.Column(sa.LargeBinary)
-    bid_accept_msg_id2 = sa.Column(sa.LargeBinary)
-    bid_accept_msg_id3 = sa.Column(sa.LargeBinary)
-
-    coin_a_lock_tx_sigs_l_msg_id = sa.Column(sa.LargeBinary)  # MSG3L F -> L
-    coin_a_lock_refund_spend_tx_msg_id = sa.Column(sa.LargeBinary)  # MSG4F L -> F
 
     contract_count = sa.Column(sa.Integer)
 
@@ -349,6 +371,8 @@ class XmrSplitData(Base):
     __tablename__ = 'xmr_split_data'
 
     record_id = sa.Column(sa.Integer, primary_key=True, autoincrement=True)
+    addr_from = sa.Column(sa.String)
+    addr_to = sa.Column(sa.String)
     bid_id = sa.Column(sa.LargeBinary)
     msg_type = sa.Column(sa.Integer)
     msg_sequence = sa.Column(sa.Integer)
@@ -372,12 +396,11 @@ class Wallets(Base):
     __tablename__ = 'wallets'
 
     record_id = sa.Column(sa.Integer, primary_key=True, autoincrement=True)
+    active_ind = sa.Column(sa.Integer)
     coin_id = sa.Column(sa.Integer)
     wallet_name = sa.Column(sa.String)
     wallet_data = sa.Column(sa.String)
     balance_type = sa.Column(sa.Integer)
-    amount = sa.Column(sa.BigInteger)
-    updated_at = sa.Column(sa.BigInteger)
     created_at = sa.Column(sa.BigInteger)
 
 
@@ -385,6 +408,7 @@ class KnownIdentity(Base):
     __tablename__ = 'knownidentities'
 
     record_id = sa.Column(sa.Integer, primary_key=True, autoincrement=True)
+    active_ind = sa.Column(sa.Integer)
     address = sa.Column(sa.String)
     label = sa.Column(sa.String)
     publickey = sa.Column(sa.LargeBinary)
@@ -394,6 +418,99 @@ class KnownIdentity(Base):
     num_recv_bids_rejected = sa.Column(sa.Integer)
     num_sent_bids_failed = sa.Column(sa.Integer)
     num_recv_bids_failed = sa.Column(sa.Integer)
+    automation_override = sa.Column(sa.Integer)  # AutomationOverrideOptions
+    visibility_override = sa.Column(sa.Integer)  # VisibilityOverrideOptions
+    data = sa.Column(sa.LargeBinary)
     note = sa.Column(sa.String)
     updated_at = sa.Column(sa.BigInteger)
     created_at = sa.Column(sa.BigInteger)
+
+
+class AutomationStrategy(Base):
+    __tablename__ = 'automationstrategies'
+
+    record_id = sa.Column(sa.Integer, primary_key=True, autoincrement=True)
+    active_ind = sa.Column(sa.Integer)
+
+    label = sa.Column(sa.String)
+    type_ind = sa.Column(sa.Integer)
+    only_known_identities = sa.Column(sa.Integer)
+    num_concurrent = sa.Column(sa.Integer)
+    data = sa.Column(sa.LargeBinary)
+
+    note = sa.Column(sa.String)
+    created_at = sa.Column(sa.BigInteger)
+
+
+class AutomationLink(Base):
+    __tablename__ = 'automationlinks'
+    # Contains per order/bid options
+
+    record_id = sa.Column(sa.Integer, primary_key=True, autoincrement=True)
+    active_ind = sa.Column(sa.Integer)
+
+    linked_type = sa.Column(sa.Integer)
+    linked_id = sa.Column(sa.LargeBinary)
+    strategy_id = sa.Column(sa.Integer)
+
+    data = sa.Column(sa.LargeBinary)
+    repeat_limit = sa.Column(sa.Integer)
+    repeat_count = sa.Column(sa.Integer)
+
+    note = sa.Column(sa.String)
+    created_at = sa.Column(sa.BigInteger)
+
+    __table_args__ = (sa.Index('linked_index', 'linked_type', 'linked_id'), )
+
+
+class History(Base):
+    __tablename__ = 'history'
+
+    record_id = sa.Column(sa.Integer, primary_key=True, autoincrement=True)
+    concept_type = sa.Column(sa.Integer)
+    concept_id = sa.Column(sa.Integer)
+
+    changed_data = sa.Column(sa.LargeBinary)
+    created_at = sa.Column(sa.BigInteger)
+
+
+class BidState(Base):
+    __tablename__ = 'bidstates'
+
+    record_id = sa.Column(sa.Integer, primary_key=True, autoincrement=True)
+    active_ind = sa.Column(sa.Integer)
+    state_id = sa.Column(sa.Integer)
+    label = sa.Column(sa.String)
+    in_progress = sa.Column(sa.Integer)
+    in_error = sa.Column(sa.Integer)
+    swap_failed = sa.Column(sa.Integer)
+    swap_ended = sa.Column(sa.Integer)
+
+    note = sa.Column(sa.String)
+    created_at = sa.Column(sa.BigInteger)
+
+
+class Notification(Base):
+    __tablename__ = 'notifications'
+
+    record_id = sa.Column(sa.Integer, primary_key=True, autoincrement=True)
+    active_ind = sa.Column(sa.Integer)
+    created_at = sa.Column(sa.BigInteger)
+    event_type = sa.Column(sa.Integer)
+    event_data = sa.Column(sa.LargeBinary)
+
+
+class MessageLink(Base):
+    __tablename__ = 'message_links'
+
+    record_id = sa.Column(sa.Integer, primary_key=True, autoincrement=True)
+    active_ind = sa.Column(sa.Integer)
+    created_at = sa.Column(sa.BigInteger)
+
+    linked_type = sa.Column(sa.Integer)
+    linked_id = sa.Column(sa.LargeBinary)
+    # linked_row_id = sa.Column(sa.Integer)  # TODO: Find a way to use table rowids
+
+    msg_type = sa.Column(sa.Integer)
+    msg_sequence = sa.Column(sa.Integer)
+    msg_id = sa.Column(sa.LargeBinary)

basicswap/db_upgrades.py

@@ -0,0 +1,312 @@
+# -*- coding: utf-8 -*-
+
+# Copyright (c) 2022-2023 tecnovert
+# Distributed under the MIT software license, see the accompanying
+# file LICENSE or http://www.opensource.org/licenses/mit-license.php.
+
+import json
+import time
+
+from sqlalchemy.orm import scoped_session
+from .db import (
+    BidState,
+    Concepts,
+    AutomationStrategy,
+    CURRENT_DB_VERSION,
+    CURRENT_DB_DATA_VERSION)
+
+from .basicswap_util import (
+    BidStates,
+    strBidState,
+    isActiveBidState,
+    isErrorBidState,
+    isFailingBidState,
+    isFinalBidState,
+)
+
+
+def upgradeDatabaseData(self, data_version):
+    if data_version >= CURRENT_DB_DATA_VERSION:
+        return
+
+    self.log.info('Upgrading database records from version %d to %d.', data_version, CURRENT_DB_DATA_VERSION)
+    with self.mxDB:
+        try:
+            session = scoped_session(self.session_factory)
+
+            now = int(time.time())
+
+            if data_version < 1:
+                session.add(AutomationStrategy(
+                    active_ind=1,
+                    label='Accept All',
+                    type_ind=Concepts.OFFER,
+                    data=json.dumps({'exact_rate_only': True,
+                                     'max_concurrent_bids': 5}).encode('utf-8'),
+                    only_known_identities=False,
+                    created_at=now))
+                session.add(AutomationStrategy(
+                    active_ind=1,
+                    label='Accept Known',
+                    type_ind=Concepts.OFFER,
+                    data=json.dumps({'exact_rate_only': True,
+                                     'max_concurrent_bids': 5}).encode('utf-8'),
+                    only_known_identities=True,
+                    note='Accept bids from identities with previously successful swaps only',
+                    created_at=now))
+
+                for state in BidStates:
+                    session.add(BidState(
+                        active_ind=1,
+                        state_id=int(state),
+                        in_progress=isActiveBidState(state),
+                        in_error=isErrorBidState(state),
+                        swap_failed=isFailingBidState(state),
+                        swap_ended=isFinalBidState(state),
+                        label=strBidState(state),
+                        created_at=now))
+
+            if data_version > 0 and data_version < 2:
+                for state in (BidStates.XMR_SWAP_MSG_SCRIPT_LOCK_TX_SIGS, BidStates.XMR_SWAP_MSG_SCRIPT_LOCK_SPEND_TX):
+                    session.add(BidState(
+                        active_ind=1,
+                        state_id=int(state),
+                        in_progress=isActiveBidState(state),
+                        label=strBidState(state),
+                        created_at=now))
+            if data_version > 0 and data_version < 3:
+                for state in BidStates:
+                    in_error = isErrorBidState(state)
+                    swap_failed = isFailingBidState(state)
+                    swap_ended = isFinalBidState(state)
+                    session.execute('UPDATE bidstates SET in_error = :in_error, swap_failed = :swap_failed, swap_ended = :swap_ended WHERE state_id = :state_id', {'in_error': in_error, 'swap_failed': swap_failed, 'swap_ended': swap_ended, 'state_id': int(state)})
+            if data_version > 0 and data_version < 4:
+                for state in (BidStates.BID_REQUEST_SENT, BidStates.BID_REQUEST_ACCEPTED):
+                    session.add(BidState(
+                        active_ind=1,
+                        state_id=int(state),
+                        in_progress=isActiveBidState(state),
+                        in_error=isErrorBidState(state),
+                        swap_failed=isFailingBidState(state),
+                        swap_ended=isFinalBidState(state),
+                        label=strBidState(state),
+                        created_at=now))
+
+            self.db_data_version = CURRENT_DB_DATA_VERSION
+            self.setIntKVInSession('db_data_version', self.db_data_version, session)
+            session.commit()
+            self.log.info('Upgraded database records to version {}'.format(self.db_data_version))
+        finally:
+            session.close()
+            session.remove()
+
+
+def upgradeDatabase(self, db_version):
+    if db_version >= CURRENT_DB_VERSION:
+        return
+
+    self.log.info('Upgrading database from version %d to %d.', db_version, CURRENT_DB_VERSION)
+
+    while True:
+        session = scoped_session(self.session_factory)
+
+        current_version = db_version
+        if current_version == 6:
+            session.execute('ALTER TABLE bids ADD COLUMN security_token BLOB')
+            session.execute('ALTER TABLE offers ADD COLUMN security_token BLOB')
+            db_version += 1
+        elif current_version == 7:
+            session.execute('ALTER TABLE transactions ADD COLUMN block_hash BLOB')
+            session.execute('ALTER TABLE transactions ADD COLUMN block_height INTEGER')
+            session.execute('ALTER TABLE transactions ADD COLUMN block_time INTEGER')
+            db_version += 1
+        elif current_version == 8:
+            session.execute('''
+                CREATE TABLE wallets (
+                    record_id INTEGER NOT NULL,
+                    coin_id INTEGER,
+                    wallet_name VARCHAR,
+                    wallet_data VARCHAR,
+                    balance_type INTEGER,
+                    created_at BIGINT,
+                    PRIMARY KEY (record_id))''')
+            db_version += 1
+        elif current_version == 9:
+            session.execute('ALTER TABLE wallets ADD COLUMN wallet_data VARCHAR')
+            db_version += 1
+        elif current_version == 10:
+            session.execute('ALTER TABLE smsgaddresses ADD COLUMN active_ind INTEGER')
+            session.execute('ALTER TABLE smsgaddresses ADD COLUMN created_at INTEGER')
+            session.execute('ALTER TABLE smsgaddresses ADD COLUMN note VARCHAR')
+            session.execute('ALTER TABLE smsgaddresses ADD COLUMN pubkey VARCHAR')
+            session.execute('UPDATE smsgaddresses SET active_ind = 1, created_at = 1')
+
+            session.execute('ALTER TABLE offers ADD COLUMN addr_to VARCHAR')
+            session.execute(f'UPDATE offers SET addr_to = "{self.network_addr}"')
+            db_version += 1
+        elif current_version == 11:
+            session.execute('ALTER TABLE bids ADD COLUMN chain_a_height_start INTEGER')
+            session.execute('ALTER TABLE bids ADD COLUMN chain_b_height_start INTEGER')
+            session.execute('ALTER TABLE bids ADD COLUMN protocol_version INTEGER')
+            session.execute('ALTER TABLE offers ADD COLUMN protocol_version INTEGER')
+            session.execute('ALTER TABLE transactions ADD COLUMN tx_data BLOB')
+            db_version += 1
+        elif current_version == 12:
+            session.execute('''
+                CREATE TABLE knownidentities (
+                    record_id INTEGER NOT NULL,
+                    address VARCHAR,
+                    label VARCHAR,
+                    publickey BLOB,
+                    num_sent_bids_successful INTEGER,
+                    num_recv_bids_successful INTEGER,
+                    num_sent_bids_rejected INTEGER,
+                    num_recv_bids_rejected INTEGER,
+                    num_sent_bids_failed INTEGER,
+                    num_recv_bids_failed INTEGER,
+                    note VARCHAR,
+                    updated_at BIGINT,
+                    created_at BIGINT,
+                    PRIMARY KEY (record_id))''')
+            session.execute('ALTER TABLE bids ADD COLUMN reject_code INTEGER')
+            session.execute('ALTER TABLE bids ADD COLUMN rate INTEGER')
+            session.execute('ALTER TABLE offers ADD COLUMN amount_negotiable INTEGER')
+            session.execute('ALTER TABLE offers ADD COLUMN rate_negotiable INTEGER')
+            db_version += 1
+        elif current_version == 13:
+            db_version += 1
+            session.execute('''
+                CREATE TABLE automationstrategies (
+                    record_id INTEGER NOT NULL,
+                    active_ind INTEGER,
+                    label VARCHAR,
+                    type_ind INTEGER,
+                    only_known_identities INTEGER,
+                    num_concurrent INTEGER,
+                    data BLOB,
+
+                    note VARCHAR,
+                    created_at BIGINT,
+                    PRIMARY KEY (record_id))''')
+
+            session.execute('''
+                CREATE TABLE automationlinks (
+                    record_id INTEGER NOT NULL,
+                    active_ind INTEGER,
+
+                    linked_type INTEGER,
+                    linked_id BLOB,
+                    strategy_id INTEGER,
+
+                    data BLOB,
+                    repeat_limit INTEGER,
+                    repeat_count INTEGER,
+
+                    note VARCHAR,
+                    created_at BIGINT,
+                    PRIMARY KEY (record_id))''')
+
+            session.execute('''
+                CREATE TABLE history (
+                    record_id INTEGER NOT NULL,
+                    concept_type INTEGER,
+                    concept_id INTEGER,
+                    changed_data BLOB,
+
+                    note VARCHAR,
+                    created_at BIGINT,
+                    PRIMARY KEY (record_id))''')
+
+            session.execute('''
+                CREATE TABLE bidstates (
+                    record_id INTEGER NOT NULL,
+                    active_ind INTEGER,
+                    state_id INTEGER,
+                    label VARCHAR,
+                    in_progress INTEGER,
+
+                    note VARCHAR,
+                    created_at BIGINT,
+                    PRIMARY KEY (record_id))''')
+
+            session.execute('ALTER TABLE wallets ADD COLUMN active_ind INTEGER')
+            session.execute('ALTER TABLE knownidentities ADD COLUMN active_ind INTEGER')
+            session.execute('ALTER TABLE eventqueue RENAME TO actions')
+            session.execute('ALTER TABLE actions RENAME COLUMN event_id TO action_id')
+            session.execute('ALTER TABLE actions RENAME COLUMN event_type TO action_type')
+            session.execute('ALTER TABLE actions RENAME COLUMN event_data TO action_data')
+        elif current_version == 14:
+            db_version += 1
+            session.execute('ALTER TABLE xmr_swaps ADD COLUMN coin_a_lock_release_msg_id BLOB')
+            session.execute('ALTER TABLE xmr_swaps RENAME COLUMN coin_a_lock_refund_spend_tx_msg_id TO coin_a_lock_spend_tx_msg_id')
+        elif current_version == 15:
+            db_version += 1
+            session.execute('''
+                CREATE TABLE notifications (
+                    record_id INTEGER NOT NULL,
+                    active_ind INTEGER,
+                    event_type INTEGER,
+                    event_data BLOB,
+                    created_at BIGINT,
+                    PRIMARY KEY (record_id))''')
+        elif current_version == 16:
+            db_version += 1
+            session.execute('''
+                CREATE TABLE prefunded_transactions (
+                    record_id INTEGER NOT NULL,
+                    active_ind INTEGER,
+                    created_at BIGINT,
+                    linked_type INTEGER,
+                    linked_id BLOB,
+                    tx_type INTEGER,
+                    tx_data BLOB,
+                    used_by BLOB,
+                    PRIMARY KEY (record_id))''')
+        elif current_version == 17:
+            db_version += 1
+            session.execute('ALTER TABLE knownidentities ADD COLUMN automation_override INTEGER')
+            session.execute('ALTER TABLE knownidentities ADD COLUMN visibility_override INTEGER')
+            session.execute('ALTER TABLE knownidentities ADD COLUMN data BLOB')
+            session.execute('UPDATE knownidentities SET active_ind = 1')
+        elif current_version == 18:
+            db_version += 1
+            session.execute('ALTER TABLE xmr_split_data ADD COLUMN addr_from STRING')
+            session.execute('ALTER TABLE xmr_split_data ADD COLUMN addr_to STRING')
+        elif current_version == 19:
+            db_version += 1
+            session.execute('ALTER TABLE bidstates ADD COLUMN in_error INTEGER')
+            session.execute('ALTER TABLE bidstates ADD COLUMN swap_failed INTEGER')
+            session.execute('ALTER TABLE bidstates ADD COLUMN swap_ended INTEGER')
+        elif current_version == 20:
+            db_version += 1
+            session.execute('''
+                CREATE TABLE message_links (
+                    record_id INTEGER NOT NULL,
+                    active_ind INTEGER,
+                    created_at BIGINT,
+
+                    linked_type INTEGER,
+                    linked_id BLOB,
+
+                    msg_type INTEGER,
+                    msg_sequence INTEGER,
+                    msg_id BLOB,
+                    PRIMARY KEY (record_id))''')
+            session.execute('ALTER TABLE offers ADD COLUMN bid_reversed INTEGER')
+        elif current_version == 21:
+            db_version += 1
+            session.execute('ALTER TABLE offers ADD COLUMN proof_utxos BLOB')
+            session.execute('ALTER TABLE bids ADD COLUMN proof_utxos BLOB')
+
+        if current_version != db_version:
+            self.db_version = db_version
+            self.setIntKVInSession('db_version', db_version, session)
+            session.commit()
+            session.close()
+            session.remove()
+            self.log.info('Upgraded database to version {}'.format(self.db_version))
+            continue
+        break
+
+    if db_version != CURRENT_DB_VERSION:
+        raise ValueError('Unable to upgrade database.')

basicswap/db_util.py

@@ -0,0 +1,56 @@
+# -*- coding: utf-8 -*-
+
+# Copyright (c) 2023 The BSX Developers
+# Distributed under the MIT software license, see the accompanying
+# file LICENSE or http://www.opensource.org/licenses/mit-license.php.
+
+from .db import (
+    Concepts,
+)
+
+
+def remove_expired_data(self, time_offset: int = 0):
+    now: int = self.getTime()
+    try:
+        session = self.openSession()
+
+        active_bids_insert = self.activeBidsQueryStr(now, '', 'b2')
+        query_str = f'''
+                    SELECT o.offer_id FROM offers o
+                    WHERE o.expire_at <= :expired_at AND 0 = (SELECT COUNT(*) FROM bids b2 WHERE b2.offer_id = o.offer_id AND {active_bids_insert})
+                    '''
+        num_offers = 0
+        num_bids = 0
+        offer_rows = session.execute(query_str, {'expired_at': now - time_offset})
+        for offer_row in offer_rows:
+            num_offers += 1
+            bid_rows = session.execute('SELECT bids.bid_id FROM bids WHERE bids.offer_id = :offer_id', {'offer_id': offer_row[0]})
+            for bid_row in bid_rows:
+                num_bids += 1
+                session.execute('DELETE FROM transactions WHERE transactions.bid_id = :bid_id', {'bid_id': bid_row[0]})
+                session.execute('DELETE FROM eventlog WHERE eventlog.linked_type = :type_ind AND eventlog.linked_id = :bid_id', {'type_ind': int(Concepts.BID), 'bid_id': bid_row[0]})
+                session.execute('DELETE FROM automationlinks WHERE automationlinks.linked_type = :type_ind AND automationlinks.linked_id = :bid_id', {'type_ind': int(Concepts.BID), 'bid_id': bid_row[0]})
+                session.execute('DELETE FROM prefunded_transactions WHERE prefunded_transactions.linked_type = :type_ind AND prefunded_transactions.linked_id = :bid_id', {'type_ind': int(Concepts.BID), 'bid_id': bid_row[0]})
+                session.execute('DELETE FROM history WHERE history.concept_type = :type_ind AND history.concept_id = :bid_id', {'type_ind': int(Concepts.BID), 'bid_id': bid_row[0]})
+                session.execute('DELETE FROM xmr_swaps WHERE xmr_swaps.bid_id = :bid_id', {'bid_id': bid_row[0]})
+                session.execute('DELETE FROM actions WHERE actions.linked_id = :bid_id', {'bid_id': bid_row[0]})
+                session.execute('DELETE FROM addresspool WHERE addresspool.bid_id = :bid_id', {'bid_id': bid_row[0]})
+                session.execute('DELETE FROM xmr_split_data WHERE xmr_split_data.bid_id = :bid_id', {'bid_id': bid_row[0]})
+                session.execute('DELETE FROM bids WHERE bids.bid_id = :bid_id', {'bid_id': bid_row[0]})
+                session.execute('DELETE FROM message_links WHERE linked_type = :type_ind AND linked_id = :linked_id', {'type_ind': int(Concepts.BID), 'linked_id': bid_row[0]})
+
+            session.execute('DELETE FROM eventlog WHERE eventlog.linked_type = :type_ind AND eventlog.linked_id = :offer_id', {'type_ind': int(Concepts.OFFER), 'offer_id': offer_row[0]})
+            session.execute('DELETE FROM automationlinks WHERE automationlinks.linked_type = :type_ind AND automationlinks.linked_id = :offer_id', {'type_ind': int(Concepts.OFFER), 'offer_id': offer_row[0]})
+            session.execute('DELETE FROM prefunded_transactions WHERE prefunded_transactions.linked_type = :type_ind AND prefunded_transactions.linked_id = :offer_id', {'type_ind': int(Concepts.OFFER), 'offer_id': offer_row[0]})
+            session.execute('DELETE FROM history WHERE history.concept_type = :type_ind AND history.concept_id = :offer_id', {'type_ind': int(Concepts.OFFER), 'offer_id': offer_row[0]})
+            session.execute('DELETE FROM xmr_offers WHERE xmr_offers.offer_id = :offer_id', {'offer_id': offer_row[0]})
+            session.execute('DELETE FROM sentoffers WHERE sentoffers.offer_id = :offer_id', {'offer_id': offer_row[0]})
+            session.execute('DELETE FROM actions WHERE actions.linked_id = :offer_id', {'offer_id': offer_row[0]})
+            session.execute('DELETE FROM offers WHERE offers.offer_id = :offer_id', {'offer_id': offer_row[0]})
+            session.execute('DELETE FROM message_links WHERE linked_type = :type_ind AND linked_id = :offer_id', {'type_ind': int(Concepts.OFFER), 'offer_id': offer_row[0]})
+
+        if num_offers > 0 or num_bids > 0:
+            self.log.info('Removed data for {} expired offer{} and {} bid{}.'.format(num_offers, 's' if num_offers != 1 else '', num_bids, 's' if num_bids != 1 else ''))
+
+    finally:
+        self.closeSession(session)

basicswap/explorers.py

@@ -1,11 +1,10 @@
 # -*- coding: utf-8 -*-
 
-# Copyright (c) 2019-2021 tecnovert
+# Copyright (c) 2019-2023 tecnovert
 # Distributed under the MIT software license, see the accompanying
 # file LICENSE or http://www.opensource.org/licenses/mit-license.php.
 
 import json
-import urllib.request
 
 
 class Explorer():
@@ -17,9 +16,7 @@ class Explorer():
 
     def readURL(self, url):
         self.log.debug('Explorer url: {}'.format(url))
-        headers = {'User-Agent': 'Mozilla/5.0'}
-        req = urllib.request.Request(url, headers=headers)
-        return urllib.request.urlopen(req).read()
+        return self.swapclient.readURL(url)
 
 
 class ExplorerInsight(Explorer):
@@ -72,7 +69,7 @@ class ExplorerBitAps(Explorer):
         # Can't get unspents return only if exactly one transaction exists
         data = json.loads(self.readURL(self.base_url + '/address/transactions/' + address))
         try:
-            assert(data['data']['list'] == 1)
+            assert data['data']['list'] == 1
         except Exception as ex:
             self.log.debug('Explorer error: {}'.format(str(ex)))
             return None

basicswap/interface/__init__.py

@@ -0,0 +1,13 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+# Copyright (c) 2023 tecnovert
+# Distributed under the MIT software license, see the accompanying
+# file LICENSE or http://www.opensource.org/licenses/mit-license.php.
+
+from enum import IntEnum
+
+
+class Curves(IntEnum):
+    secp256k1 = 1
+    ed25519 = 2

basicswap/interface/contrib/firo_test_framework/authproxy.py

@@ -0,0 +1,191 @@
+
+"""
+  Copyright (c) 2011 Jeff Garzik
+
+  AuthServiceProxy has the following improvements over python-jsonrpc's
+  ServiceProxy class:
+
+  - HTTP connections persist for the life of the AuthServiceProxy object
+    (if server supports HTTP/1.1)
+  - sends protocol 'version', per JSON-RPC 1.1
+  - sends proper, incrementing 'id'
+  - sends Basic HTTP authentication headers
+  - parses all JSON numbers that look like floats as Decimal
+  - uses standard Python json lib
+
+  Previous copyright, from python-jsonrpc/jsonrpc/proxy.py:
+
+  Copyright (c) 2007 Jan-Klaas Kollhof
+
+  This file is part of jsonrpc.
+
+  jsonrpc is free software; you can redistribute it and/or modify
+  it under the terms of the GNU Lesser General Public License as published by
+  the Free Software Foundation; either version 2.1 of the License, or
+  (at your option) any later version.
+
+  This software is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General Public License
+  along with this software; if not, write to the Free Software
+  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+"""
+
+try:
+    import http.client as httplib
+except ImportError:
+    import httplib
+import base64
+import decimal
+import json
+import logging
+import socket
+try:
+    import urllib.parse as urlparse
+except ImportError:
+    import urlparse
+
+USER_AGENT = "AuthServiceProxy/0.1"
+
+HTTP_TIMEOUT = 30
+
+log = logging.getLogger("BitcoinRPC")
+
+class JSONRPCException(Exception):
+    def __init__(self, rpc_error):
+        try:
+            errmsg = '%(message)s (%(code)i)' % rpc_error
+        except (KeyError, TypeError):
+            errmsg = ''
+        Exception.__init__(self, errmsg)
+        self.error = rpc_error
+
+
+def EncodeDecimal(o):
+    if isinstance(o, decimal.Decimal):
+        return str(o)
+    raise TypeError(repr(o) + " is not JSON serializable")
+
+class AuthServiceProxy(object):
+    __id_count = 0
+
+    # ensure_ascii: escape unicode as \uXXXX, passed to json.dumps
+    def __init__(self, service_url, service_name=None, timeout=HTTP_TIMEOUT, connection=None, ensure_ascii=True):
+        self.__service_url = service_url
+        self._service_name = service_name
+        self.ensure_ascii = ensure_ascii # can be toggled on the fly by tests
+        self.__url = urlparse.urlparse(service_url)
+        if self.__url.port is None:
+            port = 80
+        else:
+            port = self.__url.port
+        (user, passwd) = (self.__url.username, self.__url.password)
+        try:
+            user = user.encode('utf8')
+        except AttributeError:
+            pass
+        try:
+            passwd = passwd.encode('utf8')
+        except AttributeError:
+            pass
+        authpair = user + b':' + passwd
+        self.__auth_header = b'Basic ' + base64.b64encode(authpair)
+
+        if connection:
+            # Callables re-use the connection of the original proxy
+            self.__conn = connection
+        elif self.__url.scheme == 'https':
+            self.__conn = httplib.HTTPSConnection(self.__url.hostname, port,
+                                                  timeout=timeout)
+        else:
+            self.__conn = httplib.HTTPConnection(self.__url.hostname, port,
+                                                 timeout=timeout)
+
+    def __getattr__(self, name):
+        if name.startswith('__') and name.endswith('__'):
+            # Python internal stuff
+            raise AttributeError
+        if self._service_name is not None:
+            name = "%s.%s" % (self._service_name, name)
+        return AuthServiceProxy(self.__service_url, name, connection=self.__conn)
+
+    def _request(self, method, path, postdata):
+        '''
+        Do a HTTP request, with retry if we get disconnected (e.g. due to a timeout).
+        This is a workaround for https://bugs.python.org/issue3566 which is fixed in Python 3.5.
+        '''
+        headers = {'Host': self.__url.hostname,
+                   'User-Agent': USER_AGENT,
+                   'Authorization': self.__auth_header,
+                   'Content-type': 'application/json'}
+        try:
+            self.__conn.request(method, path, postdata, headers)
+            return self._get_response()
+        except httplib.BadStatusLine as e:
+            if e.line == "''": # if connection was closed, try again
+                self.__conn.close()
+                self.__conn.request(method, path, postdata, headers)
+                return self._get_response()
+            else:
+                raise
+        except (BrokenPipeError,ConnectionResetError):
+            # Python 3.5+ raises BrokenPipeError instead of BadStatusLine when the connection was reset
+            # ConnectionResetError happens on FreeBSD with Python 3.4
+            self.__conn.close()
+            self.__conn.request(method, path, postdata, headers)
+            return self._get_response()
+
+    def __call__(self, *args, **argsn):
+        AuthServiceProxy.__id_count += 1
+
+        log.debug("-%s-> %s %s"%(AuthServiceProxy.__id_count, self._service_name,
+                                 json.dumps(args, default=EncodeDecimal, ensure_ascii=self.ensure_ascii)))
+        if args and argsn:
+            raise ValueError('Cannot handle both named and positional arguments')
+        postdata = json.dumps({'version': '1.1',
+                               'method': self._service_name,
+                               'params': args or argsn,
+                               'id': AuthServiceProxy.__id_count}, default=EncodeDecimal, ensure_ascii=self.ensure_ascii)
+        response = self._request('POST', self.__url.path, postdata.encode('utf-8'))
+        if response['error'] is not None:
+            raise JSONRPCException(response['error'])
+        elif 'result' not in response:
+            raise JSONRPCException({
+                'code': -343, 'message': 'missing JSON-RPC result'})
+        else:
+            return response['result']
+
+    def _batch(self, rpc_call_list):
+        postdata = json.dumps(list(rpc_call_list), default=EncodeDecimal, ensure_ascii=self.ensure_ascii)
+        log.debug("--> "+postdata)
+        return self._request('POST', self.__url.path, postdata.encode('utf-8'))
+
+    def _get_response(self):
+        try:
+            http_response = self.__conn.getresponse()
+        except socket.timeout as e:
+            raise JSONRPCException({
+                'code': -344,
+                'message': '%r RPC took longer than %f seconds. Consider '
+                           'using larger timeout for calls that take '
+                           'longer to return.' % (self._service_name,
+                                                  self.__conn.timeout)})
+        if http_response is None:
+            raise JSONRPCException({
+                'code': -342, 'message': 'missing HTTP response from server'})
+
+        content_type = http_response.getheader('Content-Type')
+        if content_type != 'application/json':
+            raise JSONRPCException({
+                'code': -342, 'message': 'non-JSON HTTP response with \'%i %s\' from server' % (http_response.status, http_response.reason)})
+
+        responsedata = http_response.read().decode('utf8')
+        response = json.loads(responsedata, parse_float=decimal.Decimal)
+        if "error" in response and response["error"] is None:
+            log.debug("<-%s- %s"%(response["id"], json.dumps(response["result"], default=EncodeDecimal, ensure_ascii=self.ensure_ascii)))
+        else:
+            log.debug("<-- "+responsedata)
+        return response

basicswap/interface/contrib/firo_test_framework/bignum.py

@@ -0,0 +1,101 @@
+#!/usr/bin/env python3
+#
+# bignum.py
+#
+# This file is copied from python-bitcoinlib.
+#
+# Distributed under the MIT software license, see the accompanying
+# file COPYING or http://www.opensource.org/licenses/mit-license.php.
+#
+
+"""Bignum routines"""
+
+
+import struct
+
+
+# generic big endian MPI format
+
+def bn_bytes(v, have_ext=False):
+    ext = 0
+    if have_ext:
+        ext = 1
+    return ((v.bit_length()+7)//8) + ext
+
+def bn2bin(v):
+    s = bytearray()
+    i = bn_bytes(v)
+    while i > 0:
+        s.append((v >> ((i-1) * 8)) & 0xff)
+        i -= 1
+    return s
+
+def bin2bn(s):
+    l = 0
+    for ch in s:
+        l = (l << 8) | ch
+    return l
+
+def bn2mpi(v):
+    have_ext = False
+    if v.bit_length() > 0:
+        have_ext = (v.bit_length() & 0x07) == 0
+
+    neg = False
+    if v < 0:
+        neg = True
+        v = -v
+
+    s = struct.pack(b">I", bn_bytes(v, have_ext))
+    ext = bytearray()
+    if have_ext:
+        ext.append(0)
+    v_bin = bn2bin(v)
+    if neg:
+        if have_ext:
+            ext[0] |= 0x80
+        else:
+            v_bin[0] |= 0x80
+    return s + ext + v_bin
+
+def mpi2bn(s):
+    if len(s) < 4:
+        return None
+    s_size = bytes(s[:4])
+    v_len = struct.unpack(b">I", s_size)[0]
+    if len(s) != (v_len + 4):
+        return None
+    if v_len == 0:
+        return 0
+
+    v_str = bytearray(s[4:])
+    neg = False
+    i = v_str[0]
+    if i & 0x80:
+        neg = True
+        i &= ~0x80
+        v_str[0] = i
+
+    v = bin2bn(v_str)
+
+    if neg:
+        return -v
+    return v
+
+# bitcoin-specific little endian format, with implicit size
+def mpi2vch(s):
+    r = s[4:]           # strip size
+    r = r[::-1]         # reverse string, converting BE->LE
+    return r
+
+def bn2vch(v):
+    return bytes(mpi2vch(bn2mpi(v)))
+
+def vch2mpi(s):
+    r = struct.pack(b">I", len(s))   # size
+    r += s[::-1]            # reverse string, converting LE->BE
+    return r
+
+def vch2bn(s):
+    return mpi2bn(vch2mpi(s))
+

basicswap/interface/contrib/firo_test_framework/coverage.py

@@ -0,0 +1,106 @@
+#!/usr/bin/env python3
+# Copyright (c) 2015-2016 The Bitcoin Core developers
+# Distributed under the MIT software license, see the accompanying
+# file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+"""
+This module contains utilities for doing coverage analysis on the RPC
+interface.
+
+It provides a way to track which RPC commands are exercised during
+testing.
+
+"""
+import os
+
+
+REFERENCE_FILENAME = 'rpc_interface.txt'
+
+
+class AuthServiceProxyWrapper(object):
+    """
+    An object that wraps AuthServiceProxy to record specific RPC calls.
+
+    """
+    def __init__(self, auth_service_proxy_instance, coverage_logfile=None):
+        """
+        Kwargs:
+            auth_service_proxy_instance (AuthServiceProxy): the instance
+                being wrapped.
+            coverage_logfile (str): if specified, write each service_name
+                out to a file when called.
+
+        """
+        self.auth_service_proxy_instance = auth_service_proxy_instance
+        self.coverage_logfile = coverage_logfile
+
+    def __getattr__(self, *args, **kwargs):
+        return_val = self.auth_service_proxy_instance.__getattr__(
+            *args, **kwargs)
+
+        return AuthServiceProxyWrapper(return_val, self.coverage_logfile)
+
+    def __call__(self, *args, **kwargs):
+        """
+        Delegates to AuthServiceProxy, then writes the particular RPC method
+        called to a file.
+
+        """
+        return_val = self.auth_service_proxy_instance.__call__(*args, **kwargs)
+        rpc_method = self.auth_service_proxy_instance._service_name
+
+        if self.coverage_logfile:
+            with open(self.coverage_logfile, 'a+', encoding='utf8') as f:
+                f.write("%s\n" % rpc_method)
+
+        return return_val
+
+    @property
+    def url(self):
+        return self.auth_service_proxy_instance.url
+
+
+def get_filename(dirname, n_node):
+    """
+    Get a filename unique to the test process ID and node.
+
+    This file will contain a list of RPC commands covered.
+    """
+    pid = str(os.getpid())
+    return os.path.join(
+        dirname, "coverage.pid%s.node%s.txt" % (pid, str(n_node)))
+
+
+def write_all_rpc_commands(dirname, node):
+    """
+    Write out a list of all RPC functions available in `bitcoin-cli` for
+    coverage comparison. This will only happen once per coverage
+    directory.
+
+    Args:
+        dirname (str): temporary test dir
+        node (AuthServiceProxy): client
+
+    Returns:
+        bool. if the RPC interface file was written.
+
+    """
+    filename = os.path.join(dirname, REFERENCE_FILENAME)
+
+    if os.path.isfile(filename):
+        return False
+
+    help_output = node.help().split('\n')
+    commands = set()
+
+    for line in help_output:
+        line = line.strip()
+
+        # Ignore blanks and headers
+        if line and not line.startswith('='):
+            commands.add("%s\n" % line.split()[0])
+
+    with open(filename, 'w', encoding='utf8') as f:
+        f.writelines(list(commands))
+
+    return True

basicswap/interface/contrib/firo_test_framework/script.py

@@ -0,0 +1,943 @@
+#!/usr/bin/env python3
+# Copyright (c) 2015-2016 The Bitcoin Core developers
+# Distributed under the MIT software license, see the accompanying
+# file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#
+# script.py
+#
+# This file is modified from python-bitcoinlib.
+#
+
+"""Scripts
+
+Functionality to build scripts, as well as SignatureHash().
+"""
+
+
+from .mininode import CTransaction, CTxOut, sha256, hash256, uint256_from_str, ser_uint256, ser_string
+from binascii import hexlify
+import hashlib
+
+import sys
+bchr = chr
+bord = ord
+if sys.version > '3':
+    long = int
+    bchr = lambda x: bytes([x])
+    bord = lambda x: x
+
+import struct
+
+from .bignum import bn2vch
+
+MAX_SCRIPT_SIZE = 10000
+MAX_SCRIPT_ELEMENT_SIZE = 520
+MAX_SCRIPT_OPCODES = 201
+
+OPCODE_NAMES = {}
+
+_opcode_instances = []
+class CScriptOp(int):
+    """A single script opcode"""
+    __slots__ = []
+
+    @staticmethod
+    def encode_op_pushdata(d):
+        """Encode a PUSHDATA op, returning bytes"""
+        if len(d) < 0x4c:
+            return b'' + bchr(len(d)) + d # OP_PUSHDATA
+        elif len(d) <= 0xff:
+            return b'\x4c' + bchr(len(d)) + d # OP_PUSHDATA1
+        elif len(d) <= 0xffff:
+            return b'\x4d' + struct.pack(b'<H', len(d)) + d # OP_PUSHDATA2
+        elif len(d) <= 0xffffffff:
+            return b'\x4e' + struct.pack(b'<I', len(d)) + d # OP_PUSHDATA4
+        else:
+            raise ValueError("Data too long to encode in a PUSHDATA op")
+
+    @staticmethod
+    def encode_op_n(n):
+        """Encode a small integer op, returning an opcode"""
+        if not (0 <= n <= 16):
+            raise ValueError('Integer must be in range 0 <= n <= 16, got %d' % n)
+
+        if n == 0:
+            return OP_0
+        else:
+            return CScriptOp(OP_1 + n-1)
+
+    def decode_op_n(self):
+        """Decode a small integer opcode, returning an integer"""
+        if self == OP_0:
+            return 0
+
+        if not (self == OP_0 or OP_1 <= self <= OP_16):
+            raise ValueError('op %r is not an OP_N' % self)
+
+        return int(self - OP_1+1)
+
+    def is_small_int(self):
+        """Return true if the op pushes a small integer to the stack"""
+        if 0x51 <= self <= 0x60 or self == 0:
+            return True
+        else:
+            return False
+
+    def __str__(self):
+        return repr(self)
+
+    def __repr__(self):
+        if self in OPCODE_NAMES:
+            return OPCODE_NAMES[self]
+        else:
+            return 'CScriptOp(0x%x)' % self
+
+    def __new__(cls, n):
+        try:
+            return _opcode_instances[n]
+        except IndexError:
+            assert len(_opcode_instances) == n
+            _opcode_instances.append(super(CScriptOp, cls).__new__(cls, n))
+            return _opcode_instances[n]
+
+# Populate opcode instance table
+for n in range(0xff+1):
+    CScriptOp(n)
+
+
+# push value
+OP_0 = CScriptOp(0x00)
+OP_FALSE = OP_0
+OP_PUSHDATA1 = CScriptOp(0x4c)
+OP_PUSHDATA2 = CScriptOp(0x4d)
+OP_PUSHDATA4 = CScriptOp(0x4e)
+OP_1NEGATE = CScriptOp(0x4f)
+OP_RESERVED = CScriptOp(0x50)
+OP_1 = CScriptOp(0x51)
+OP_TRUE=OP_1
+OP_2 = CScriptOp(0x52)
+OP_3 = CScriptOp(0x53)
+OP_4 = CScriptOp(0x54)
+OP_5 = CScriptOp(0x55)
+OP_6 = CScriptOp(0x56)
+OP_7 = CScriptOp(0x57)
+OP_8 = CScriptOp(0x58)
+OP_9 = CScriptOp(0x59)
+OP_10 = CScriptOp(0x5a)
+OP_11 = CScriptOp(0x5b)
+OP_12 = CScriptOp(0x5c)
+OP_13 = CScriptOp(0x5d)
+OP_14 = CScriptOp(0x5e)
+OP_15 = CScriptOp(0x5f)
+OP_16 = CScriptOp(0x60)
+
+# control
+OP_NOP = CScriptOp(0x61)
+OP_VER = CScriptOp(0x62)
+OP_IF = CScriptOp(0x63)
+OP_NOTIF = CScriptOp(0x64)
+OP_VERIF = CScriptOp(0x65)
+OP_VERNOTIF = CScriptOp(0x66)
+OP_ELSE = CScriptOp(0x67)
+OP_ENDIF = CScriptOp(0x68)
+OP_VERIFY = CScriptOp(0x69)
+OP_RETURN = CScriptOp(0x6a)
+
+# stack ops
+OP_TOALTSTACK = CScriptOp(0x6b)
+OP_FROMALTSTACK = CScriptOp(0x6c)
+OP_2DROP = CScriptOp(0x6d)
+OP_2DUP = CScriptOp(0x6e)
+OP_3DUP = CScriptOp(0x6f)
+OP_2OVER = CScriptOp(0x70)
+OP_2ROT = CScriptOp(0x71)
+OP_2SWAP = CScriptOp(0x72)
+OP_IFDUP = CScriptOp(0x73)
+OP_DEPTH = CScriptOp(0x74)
+OP_DROP = CScriptOp(0x75)
+OP_DUP = CScriptOp(0x76)
+OP_NIP = CScriptOp(0x77)
+OP_OVER = CScriptOp(0x78)
+OP_PICK = CScriptOp(0x79)
+OP_ROLL = CScriptOp(0x7a)
+OP_ROT = CScriptOp(0x7b)
+OP_SWAP = CScriptOp(0x7c)
+OP_TUCK = CScriptOp(0x7d)
+
+# splice ops
+OP_CAT = CScriptOp(0x7e)
+OP_SUBSTR = CScriptOp(0x7f)
+OP_LEFT = CScriptOp(0x80)
+OP_RIGHT = CScriptOp(0x81)
+OP_SIZE = CScriptOp(0x82)
+
+# bit logic
+OP_INVERT = CScriptOp(0x83)
+OP_AND = CScriptOp(0x84)
+OP_OR = CScriptOp(0x85)
+OP_XOR = CScriptOp(0x86)
+OP_EQUAL = CScriptOp(0x87)
+OP_EQUALVERIFY = CScriptOp(0x88)
+OP_RESERVED1 = CScriptOp(0x89)
+OP_RESERVED2 = CScriptOp(0x8a)
+
+# numeric
+OP_1ADD = CScriptOp(0x8b)
+OP_1SUB = CScriptOp(0x8c)
+OP_2MUL = CScriptOp(0x8d)
+OP_2DIV = CScriptOp(0x8e)
+OP_NEGATE = CScriptOp(0x8f)
+OP_ABS = CScriptOp(0x90)
+OP_NOT = CScriptOp(0x91)
+OP_0NOTEQUAL = CScriptOp(0x92)
+
+OP_ADD = CScriptOp(0x93)
+OP_SUB = CScriptOp(0x94)
+OP_MUL = CScriptOp(0x95)
+OP_DIV = CScriptOp(0x96)
+OP_MOD = CScriptOp(0x97)
+OP_LSHIFT = CScriptOp(0x98)
+OP_RSHIFT = CScriptOp(0x99)
+
+OP_BOOLAND = CScriptOp(0x9a)
+OP_BOOLOR = CScriptOp(0x9b)
+OP_NUMEQUAL = CScriptOp(0x9c)
+OP_NUMEQUALVERIFY = CScriptOp(0x9d)
+OP_NUMNOTEQUAL = CScriptOp(0x9e)
+OP_LESSTHAN = CScriptOp(0x9f)
+OP_GREATERTHAN = CScriptOp(0xa0)
+OP_LESSTHANOREQUAL = CScriptOp(0xa1)
+OP_GREATERTHANOREQUAL = CScriptOp(0xa2)
+OP_MIN = CScriptOp(0xa3)
+OP_MAX = CScriptOp(0xa4)
+
+OP_WITHIN = CScriptOp(0xa5)
+
+# crypto
+OP_RIPEMD160 = CScriptOp(0xa6)
+OP_SHA1 = CScriptOp(0xa7)
+OP_SHA256 = CScriptOp(0xa8)
+OP_HASH160 = CScriptOp(0xa9)
+OP_HASH256 = CScriptOp(0xaa)
+OP_CODESEPARATOR = CScriptOp(0xab)
+OP_CHECKSIG = CScriptOp(0xac)
+OP_CHECKSIGVERIFY = CScriptOp(0xad)
+OP_CHECKMULTISIG = CScriptOp(0xae)
+OP_CHECKMULTISIGVERIFY = CScriptOp(0xaf)
+
+# expansion
+OP_NOP1 = CScriptOp(0xb0)
+OP_CHECKLOCKTIMEVERIFY = CScriptOp(0xb1)
+OP_CHECKSEQUENCEVERIFY = CScriptOp(0xb2)
+OP_NOP4 = CScriptOp(0xb3)
+OP_NOP5 = CScriptOp(0xb4)
+OP_NOP6 = CScriptOp(0xb5)
+OP_NOP7 = CScriptOp(0xb6)
+OP_NOP8 = CScriptOp(0xb7)
+OP_NOP9 = CScriptOp(0xb8)
+OP_NOP10 = CScriptOp(0xb9)
+
+# template matching params
+OP_SMALLINTEGER = CScriptOp(0xfa)
+OP_PUBKEYS = CScriptOp(0xfb)
+OP_PUBKEYHASH = CScriptOp(0xfd)
+OP_PUBKEY = CScriptOp(0xfe)
+
+OP_INVALIDOPCODE = CScriptOp(0xff)
+
+VALID_OPCODES = {
+    OP_1NEGATE,
+    OP_RESERVED,
+    OP_1,
+    OP_2,
+    OP_3,
+    OP_4,
+    OP_5,
+    OP_6,
+    OP_7,
+    OP_8,
+    OP_9,
+    OP_10,
+    OP_11,
+    OP_12,
+    OP_13,
+    OP_14,
+    OP_15,
+    OP_16,
+
+    OP_NOP,
+    OP_VER,
+    OP_IF,
+    OP_NOTIF,
+    OP_VERIF,
+    OP_VERNOTIF,
+    OP_ELSE,
+    OP_ENDIF,
+    OP_VERIFY,
+    OP_RETURN,
+
+    OP_TOALTSTACK,
+    OP_FROMALTSTACK,
+    OP_2DROP,
+    OP_2DUP,
+    OP_3DUP,
+    OP_2OVER,
+    OP_2ROT,
+    OP_2SWAP,
+    OP_IFDUP,
+    OP_DEPTH,
+    OP_DROP,
+    OP_DUP,
+    OP_NIP,
+    OP_OVER,
+    OP_PICK,
+    OP_ROLL,
+    OP_ROT,
+    OP_SWAP,
+    OP_TUCK,
+
+    OP_CAT,
+    OP_SUBSTR,
+    OP_LEFT,
+    OP_RIGHT,
+    OP_SIZE,
+
+    OP_INVERT,
+    OP_AND,
+    OP_OR,
+    OP_XOR,
+    OP_EQUAL,
+    OP_EQUALVERIFY,
+    OP_RESERVED1,
+    OP_RESERVED2,
+
+    OP_1ADD,
+    OP_1SUB,
+    OP_2MUL,
+    OP_2DIV,
+    OP_NEGATE,
+    OP_ABS,
+    OP_NOT,
+    OP_0NOTEQUAL,
+
+    OP_ADD,
+    OP_SUB,
+    OP_MUL,
+    OP_DIV,
+    OP_MOD,
+    OP_LSHIFT,
+    OP_RSHIFT,
+
+    OP_BOOLAND,
+    OP_BOOLOR,
+    OP_NUMEQUAL,
+    OP_NUMEQUALVERIFY,
+    OP_NUMNOTEQUAL,
+    OP_LESSTHAN,
+    OP_GREATERTHAN,
+    OP_LESSTHANOREQUAL,
+    OP_GREATERTHANOREQUAL,
+    OP_MIN,
+    OP_MAX,
+
+    OP_WITHIN,
+
+    OP_RIPEMD160,
+    OP_SHA1,
+    OP_SHA256,
+    OP_HASH160,
+    OP_HASH256,
+    OP_CODESEPARATOR,
+    OP_CHECKSIG,
+    OP_CHECKSIGVERIFY,
+    OP_CHECKMULTISIG,
+    OP_CHECKMULTISIGVERIFY,
+
+    OP_NOP1,
+    OP_CHECKLOCKTIMEVERIFY,
+    OP_CHECKSEQUENCEVERIFY,
+    OP_NOP4,
+    OP_NOP5,
+    OP_NOP6,
+    OP_NOP7,
+    OP_NOP8,
+    OP_NOP9,
+    OP_NOP10,
+
+    OP_SMALLINTEGER,
+    OP_PUBKEYS,
+    OP_PUBKEYHASH,
+    OP_PUBKEY,
+}
+
+OPCODE_NAMES.update({
+    OP_0 : 'OP_0',
+    OP_PUSHDATA1 : 'OP_PUSHDATA1',
+    OP_PUSHDATA2 : 'OP_PUSHDATA2',
+    OP_PUSHDATA4 : 'OP_PUSHDATA4',
+    OP_1NEGATE : 'OP_1NEGATE',
+    OP_RESERVED : 'OP_RESERVED',
+    OP_1 : 'OP_1',
+    OP_2 : 'OP_2',
+    OP_3 : 'OP_3',
+    OP_4 : 'OP_4',
+    OP_5 : 'OP_5',
+    OP_6 : 'OP_6',
+    OP_7 : 'OP_7',
+    OP_8 : 'OP_8',
+    OP_9 : 'OP_9',
+    OP_10 : 'OP_10',
+    OP_11 : 'OP_11',
+    OP_12 : 'OP_12',
+    OP_13 : 'OP_13',
+    OP_14 : 'OP_14',
+    OP_15 : 'OP_15',
+    OP_16 : 'OP_16',
+    OP_NOP : 'OP_NOP',
+    OP_VER : 'OP_VER',
+    OP_IF : 'OP_IF',
+    OP_NOTIF : 'OP_NOTIF',
+    OP_VERIF : 'OP_VERIF',
+    OP_VERNOTIF : 'OP_VERNOTIF',
+    OP_ELSE : 'OP_ELSE',
+    OP_ENDIF : 'OP_ENDIF',
+    OP_VERIFY : 'OP_VERIFY',
+    OP_RETURN : 'OP_RETURN',
+    OP_TOALTSTACK : 'OP_TOALTSTACK',
+    OP_FROMALTSTACK : 'OP_FROMALTSTACK',
+    OP_2DROP : 'OP_2DROP',
+    OP_2DUP : 'OP_2DUP',
+    OP_3DUP : 'OP_3DUP',
+    OP_2OVER : 'OP_2OVER',
+    OP_2ROT : 'OP_2ROT',
+    OP_2SWAP : 'OP_2SWAP',
+    OP_IFDUP : 'OP_IFDUP',
+    OP_DEPTH : 'OP_DEPTH',
+    OP_DROP : 'OP_DROP',
+    OP_DUP : 'OP_DUP',
+    OP_NIP : 'OP_NIP',
+    OP_OVER : 'OP_OVER',
+    OP_PICK : 'OP_PICK',
+    OP_ROLL : 'OP_ROLL',
+    OP_ROT : 'OP_ROT',
+    OP_SWAP : 'OP_SWAP',
+    OP_TUCK : 'OP_TUCK',
+    OP_CAT : 'OP_CAT',
+    OP_SUBSTR : 'OP_SUBSTR',
+    OP_LEFT : 'OP_LEFT',
+    OP_RIGHT : 'OP_RIGHT',
+    OP_SIZE : 'OP_SIZE',
+    OP_INVERT : 'OP_INVERT',
+    OP_AND : 'OP_AND',
+    OP_OR : 'OP_OR',
+    OP_XOR : 'OP_XOR',
+    OP_EQUAL : 'OP_EQUAL',
+    OP_EQUALVERIFY : 'OP_EQUALVERIFY',
+    OP_RESERVED1 : 'OP_RESERVED1',
+    OP_RESERVED2 : 'OP_RESERVED2',
+    OP_1ADD : 'OP_1ADD',
+    OP_1SUB : 'OP_1SUB',
+    OP_2MUL : 'OP_2MUL',
+    OP_2DIV : 'OP_2DIV',
+    OP_NEGATE : 'OP_NEGATE',
+    OP_ABS : 'OP_ABS',
+    OP_NOT : 'OP_NOT',
+    OP_0NOTEQUAL : 'OP_0NOTEQUAL',
+    OP_ADD : 'OP_ADD',
+    OP_SUB : 'OP_SUB',
+    OP_MUL : 'OP_MUL',
+    OP_DIV : 'OP_DIV',
+    OP_MOD : 'OP_MOD',
+    OP_LSHIFT : 'OP_LSHIFT',
+    OP_RSHIFT : 'OP_RSHIFT',
+    OP_BOOLAND : 'OP_BOOLAND',
+    OP_BOOLOR : 'OP_BOOLOR',
+    OP_NUMEQUAL : 'OP_NUMEQUAL',
+    OP_NUMEQUALVERIFY : 'OP_NUMEQUALVERIFY',
+    OP_NUMNOTEQUAL : 'OP_NUMNOTEQUAL',
+    OP_LESSTHAN : 'OP_LESSTHAN',
+    OP_GREATERTHAN : 'OP_GREATERTHAN',
+    OP_LESSTHANOREQUAL : 'OP_LESSTHANOREQUAL',
+    OP_GREATERTHANOREQUAL : 'OP_GREATERTHANOREQUAL',
+    OP_MIN : 'OP_MIN',
+    OP_MAX : 'OP_MAX',
+    OP_WITHIN : 'OP_WITHIN',
+    OP_RIPEMD160 : 'OP_RIPEMD160',
+    OP_SHA1 : 'OP_SHA1',
+    OP_SHA256 : 'OP_SHA256',
+    OP_HASH160 : 'OP_HASH160',
+    OP_HASH256 : 'OP_HASH256',
+    OP_CODESEPARATOR : 'OP_CODESEPARATOR',
+    OP_CHECKSIG : 'OP_CHECKSIG',
+    OP_CHECKSIGVERIFY : 'OP_CHECKSIGVERIFY',
+    OP_CHECKMULTISIG : 'OP_CHECKMULTISIG',
+    OP_CHECKMULTISIGVERIFY : 'OP_CHECKMULTISIGVERIFY',
+    OP_NOP1 : 'OP_NOP1',
+    OP_CHECKLOCKTIMEVERIFY : 'OP_CHECKLOCKTIMEVERIFY',
+    OP_CHECKSEQUENCEVERIFY : 'OP_CHECKSEQUENCEVERIFY',
+    OP_NOP4 : 'OP_NOP4',
+    OP_NOP5 : 'OP_NOP5',
+    OP_NOP6 : 'OP_NOP6',
+    OP_NOP7 : 'OP_NOP7',
+    OP_NOP8 : 'OP_NOP8',
+    OP_NOP9 : 'OP_NOP9',
+    OP_NOP10 : 'OP_NOP10',
+    OP_SMALLINTEGER : 'OP_SMALLINTEGER',
+    OP_PUBKEYS : 'OP_PUBKEYS',
+    OP_PUBKEYHASH : 'OP_PUBKEYHASH',
+    OP_PUBKEY : 'OP_PUBKEY',
+    OP_INVALIDOPCODE : 'OP_INVALIDOPCODE',
+})
+
+OPCODES_BY_NAME = {
+    'OP_0' : OP_0,
+    'OP_PUSHDATA1' : OP_PUSHDATA1,
+    'OP_PUSHDATA2' : OP_PUSHDATA2,
+    'OP_PUSHDATA4' : OP_PUSHDATA4,
+    'OP_1NEGATE' : OP_1NEGATE,
+    'OP_RESERVED' : OP_RESERVED,
+    'OP_1' : OP_1,
+    'OP_2' : OP_2,
+    'OP_3' : OP_3,
+    'OP_4' : OP_4,
+    'OP_5' : OP_5,
+    'OP_6' : OP_6,
+    'OP_7' : OP_7,
+    'OP_8' : OP_8,
+    'OP_9' : OP_9,
+    'OP_10' : OP_10,
+    'OP_11' : OP_11,
+    'OP_12' : OP_12,
+    'OP_13' : OP_13,
+    'OP_14' : OP_14,
+    'OP_15' : OP_15,
+    'OP_16' : OP_16,
+    'OP_NOP' : OP_NOP,
+    'OP_VER' : OP_VER,
+    'OP_IF' : OP_IF,
+    'OP_NOTIF' : OP_NOTIF,
+    'OP_VERIF' : OP_VERIF,
+    'OP_VERNOTIF' : OP_VERNOTIF,
+    'OP_ELSE' : OP_ELSE,
+    'OP_ENDIF' : OP_ENDIF,
+    'OP_VERIFY' : OP_VERIFY,
+    'OP_RETURN' : OP_RETURN,
+    'OP_TOALTSTACK' : OP_TOALTSTACK,
+    'OP_FROMALTSTACK' : OP_FROMALTSTACK,
+    'OP_2DROP' : OP_2DROP,
+    'OP_2DUP' : OP_2DUP,
+    'OP_3DUP' : OP_3DUP,
+    'OP_2OVER' : OP_2OVER,
+    'OP_2ROT' : OP_2ROT,
+    'OP_2SWAP' : OP_2SWAP,
+    'OP_IFDUP' : OP_IFDUP,
+    'OP_DEPTH' : OP_DEPTH,
+    'OP_DROP' : OP_DROP,
+    'OP_DUP' : OP_DUP,
+    'OP_NIP' : OP_NIP,
+    'OP_OVER' : OP_OVER,
+    'OP_PICK' : OP_PICK,
+    'OP_ROLL' : OP_ROLL,
+    'OP_ROT' : OP_ROT,
+    'OP_SWAP' : OP_SWAP,
+    'OP_TUCK' : OP_TUCK,
+    'OP_CAT' : OP_CAT,
+    'OP_SUBSTR' : OP_SUBSTR,
+    'OP_LEFT' : OP_LEFT,
+    'OP_RIGHT' : OP_RIGHT,
+    'OP_SIZE' : OP_SIZE,
+    'OP_INVERT' : OP_INVERT,
+    'OP_AND' : OP_AND,
+    'OP_OR' : OP_OR,
+    'OP_XOR' : OP_XOR,
+    'OP_EQUAL' : OP_EQUAL,
+    'OP_EQUALVERIFY' : OP_EQUALVERIFY,
+    'OP_RESERVED1' : OP_RESERVED1,
+    'OP_RESERVED2' : OP_RESERVED2,
+    'OP_1ADD' : OP_1ADD,
+    'OP_1SUB' : OP_1SUB,
+    'OP_2MUL' : OP_2MUL,
+    'OP_2DIV' : OP_2DIV,
+    'OP_NEGATE' : OP_NEGATE,
+    'OP_ABS' : OP_ABS,
+    'OP_NOT' : OP_NOT,
+    'OP_0NOTEQUAL' : OP_0NOTEQUAL,
+    'OP_ADD' : OP_ADD,
+    'OP_SUB' : OP_SUB,
+    'OP_MUL' : OP_MUL,
+    'OP_DIV' : OP_DIV,
+    'OP_MOD' : OP_MOD,
+    'OP_LSHIFT' : OP_LSHIFT,
+    'OP_RSHIFT' : OP_RSHIFT,
+    'OP_BOOLAND' : OP_BOOLAND,
+    'OP_BOOLOR' : OP_BOOLOR,
+    'OP_NUMEQUAL' : OP_NUMEQUAL,
+    'OP_NUMEQUALVERIFY' : OP_NUMEQUALVERIFY,
+    'OP_NUMNOTEQUAL' : OP_NUMNOTEQUAL,
+    'OP_LESSTHAN' : OP_LESSTHAN,
+    'OP_GREATERTHAN' : OP_GREATERTHAN,
+    'OP_LESSTHANOREQUAL' : OP_LESSTHANOREQUAL,
+    'OP_GREATERTHANOREQUAL' : OP_GREATERTHANOREQUAL,
+    'OP_MIN' : OP_MIN,
+    'OP_MAX' : OP_MAX,
+    'OP_WITHIN' : OP_WITHIN,
+    'OP_RIPEMD160' : OP_RIPEMD160,
+    'OP_SHA1' : OP_SHA1,
+    'OP_SHA256' : OP_SHA256,
+    'OP_HASH160' : OP_HASH160,
+    'OP_HASH256' : OP_HASH256,
+    'OP_CODESEPARATOR' : OP_CODESEPARATOR,
+    'OP_CHECKSIG' : OP_CHECKSIG,
+    'OP_CHECKSIGVERIFY' : OP_CHECKSIGVERIFY,
+    'OP_CHECKMULTISIG' : OP_CHECKMULTISIG,
+    'OP_CHECKMULTISIGVERIFY' : OP_CHECKMULTISIGVERIFY,
+    'OP_NOP1' : OP_NOP1,
+    'OP_CHECKLOCKTIMEVERIFY' : OP_CHECKLOCKTIMEVERIFY,
+    'OP_CHECKSEQUENCEVERIFY' : OP_CHECKSEQUENCEVERIFY,
+    'OP_NOP4' : OP_NOP4,
+    'OP_NOP5' : OP_NOP5,
+    'OP_NOP6' : OP_NOP6,
+    'OP_NOP7' : OP_NOP7,
+    'OP_NOP8' : OP_NOP8,
+    'OP_NOP9' : OP_NOP9,
+    'OP_NOP10' : OP_NOP10,
+    'OP_SMALLINTEGER' : OP_SMALLINTEGER,
+    'OP_PUBKEYS' : OP_PUBKEYS,
+    'OP_PUBKEYHASH' : OP_PUBKEYHASH,
+    'OP_PUBKEY' : OP_PUBKEY,
+}
+
+class CScriptInvalidError(Exception):
+    """Base class for CScript exceptions"""
+    pass
+
+class CScriptTruncatedPushDataError(CScriptInvalidError):
+    """Invalid pushdata due to truncation"""
+    def __init__(self, msg, data):
+        self.data = data
+        super(CScriptTruncatedPushDataError, self).__init__(msg)
+
+# This is used, eg, for blockchain heights in coinbase scripts (bip34)
+class CScriptNum(object):
+    def __init__(self, d=0):
+        self.value = d
+
+    @staticmethod
+    def encode(obj):
+        r = bytearray(0)
+        if obj.value == 0:
+            return bytes(r)
+        neg = obj.value < 0
+        absvalue = -obj.value if neg else obj.value
+        while (absvalue):
+            r.append(absvalue & 0xff)
+            absvalue >>= 8
+        if r[-1] & 0x80:
+            r.append(0x80 if neg else 0)
+        elif neg:
+            r[-1] |= 0x80
+        return bytes(bchr(len(r)) + r)
+
+
+class CScript(bytes):
+    """Serialized script
+
+    A bytes subclass, so you can use this directly whenever bytes are accepted.
+    Note that this means that indexing does *not* work - you'll get an index by
+    byte rather than opcode. This format was chosen for efficiency so that the
+    general case would not require creating a lot of little CScriptOP objects.
+
+    iter(script) however does iterate by opcode.
+    """
+    @classmethod
+    def __coerce_instance(cls, other):
+        # Coerce other into bytes
+        if isinstance(other, CScriptOp):
+            other = bchr(other)
+        elif isinstance(other, CScriptNum):
+            if (other.value == 0):
+                other = bchr(CScriptOp(OP_0))
+            else:
+                other = CScriptNum.encode(other)
+        elif isinstance(other, int):
+            if 0 <= other <= 16:
+                other = bytes(bchr(CScriptOp.encode_op_n(other)))
+            elif other == -1:
+                other = bytes(bchr(OP_1NEGATE))
+            else:
+                other = CScriptOp.encode_op_pushdata(bn2vch(other))
+        elif isinstance(other, (bytes, bytearray)):
+            other = CScriptOp.encode_op_pushdata(other)
+        return other
+
+    def __add__(self, other):
+        # Do the coercion outside of the try block so that errors in it are
+        # noticed.
+        other = self.__coerce_instance(other)
+
+        try:
+            # bytes.__add__ always returns bytes instances unfortunately
+            return CScript(super(CScript, self).__add__(other))
+        except TypeError:
+            raise TypeError('Can not add a %r instance to a CScript' % other.__class__)
+
+    def join(self, iterable):
+        # join makes no sense for a CScript()
+        raise NotImplementedError
+
+    def __new__(cls, value=b''):
+        if isinstance(value, bytes) or isinstance(value, bytearray):
+            return super(CScript, cls).__new__(cls, value)
+        else:
+            def coerce_iterable(iterable):
+                for instance in iterable:
+                    yield cls.__coerce_instance(instance)
+            # Annoyingly on both python2 and python3 bytes.join() always
+            # returns a bytes instance even when subclassed.
+            return super(CScript, cls).__new__(cls, b''.join(coerce_iterable(value)))
+
+    def raw_iter(self):
+        """Raw iteration
+
+        Yields tuples of (opcode, data, sop_idx) so that the different possible
+        PUSHDATA encodings can be accurately distinguished, as well as
+        determining the exact opcode byte indexes. (sop_idx)
+        """
+        i = 0
+        while i < len(self):
+            sop_idx = i
+            opcode = bord(self[i])
+            i += 1
+
+            if opcode > OP_PUSHDATA4:
+                yield (opcode, None, sop_idx)
+            else:
+                datasize = None
+                pushdata_type = None
+                if opcode < OP_PUSHDATA1:
+                    pushdata_type = 'PUSHDATA(%d)' % opcode
+                    datasize = opcode
+
+                elif opcode == OP_PUSHDATA1:
+                    pushdata_type = 'PUSHDATA1'
+                    if i >= len(self):
+                        raise CScriptInvalidError('PUSHDATA1: missing data length')
+                    datasize = bord(self[i])
+                    i += 1
+
+                elif opcode == OP_PUSHDATA2:
+                    pushdata_type = 'PUSHDATA2'
+                    if i + 1 >= len(self):
+                        raise CScriptInvalidError('PUSHDATA2: missing data length')
+                    datasize = bord(self[i]) + (bord(self[i+1]) << 8)
+                    i += 2
+
+                elif opcode == OP_PUSHDATA4:
+                    pushdata_type = 'PUSHDATA4'
+                    if i + 3 >= len(self):
+                        raise CScriptInvalidError('PUSHDATA4: missing data length')
+                    datasize = bord(self[i]) + (bord(self[i+1]) << 8) + (bord(self[i+2]) << 16) + (bord(self[i+3]) << 24)
+                    i += 4
+
+                else:
+                    assert False # shouldn't happen
+
+
+                data = bytes(self[i:i+datasize])
+
+                # Check for truncation
+                if len(data) < datasize:
+                    raise CScriptTruncatedPushDataError('%s: truncated data' % pushdata_type, data)
+
+                i += datasize
+
+                yield (opcode, data, sop_idx)
+
+    def __iter__(self):
+        """'Cooked' iteration
+
+        Returns either a CScriptOP instance, an integer, or bytes, as
+        appropriate.
+
+        See raw_iter() if you need to distinguish the different possible
+        PUSHDATA encodings.
+        """
+        for (opcode, data, sop_idx) in self.raw_iter():
+            if data is not None:
+                yield data
+            else:
+                opcode = CScriptOp(opcode)
+
+                if opcode.is_small_int():
+                    yield opcode.decode_op_n()
+                else:
+                    yield CScriptOp(opcode)
+
+    def __repr__(self):
+        # For Python3 compatibility add b before strings so testcases don't
+        # need to change
+        def _repr(o):
+            if isinstance(o, bytes):
+                return b"x('%s')" % hexlify(o).decode('ascii')
+            else:
+                return repr(o)
+
+        ops = []
+        i = iter(self)
+        while True:
+            op = None
+            try:
+                op = _repr(next(i))
+            except CScriptTruncatedPushDataError as err:
+                op = '%s...<ERROR: %s>' % (_repr(err.data), err)
+                break
+            except CScriptInvalidError as err:
+                op = '<ERROR: %s>' % err
+                break
+            except StopIteration:
+                break
+            finally:
+                if op is not None:
+                    ops.append(op)
+
+        return "CScript([%s])" % ', '.join(ops)
+
+    def GetSigOpCount(self, fAccurate):
+        """Get the SigOp count.
+
+        fAccurate - Accurately count CHECKMULTISIG, see BIP16 for details.
+
+        Note that this is consensus-critical.
+        """
+        n = 0
+        lastOpcode = OP_INVALIDOPCODE
+        for (opcode, data, sop_idx) in self.raw_iter():
+            if opcode in (OP_CHECKSIG, OP_CHECKSIGVERIFY):
+                n += 1
+            elif opcode in (OP_CHECKMULTISIG, OP_CHECKMULTISIGVERIFY):
+                if fAccurate and (OP_1 <= lastOpcode <= OP_16):
+                    n += opcode.decode_op_n()
+                else:
+                    n += 20
+            lastOpcode = opcode
+        return n
+
+
+SIGHASH_ALL = 1
+SIGHASH_NONE = 2
+SIGHASH_SINGLE = 3
+SIGHASH_ANYONECANPAY = 0x80
+
+def FindAndDelete(script, sig):
+    """Consensus critical, see FindAndDelete() in Satoshi codebase"""
+    r = b''
+    last_sop_idx = sop_idx = 0
+    skip = True
+    for (opcode, data, sop_idx) in script.raw_iter():
+        if not skip:
+            r += script[last_sop_idx:sop_idx]
+        last_sop_idx = sop_idx
+        if script[sop_idx:sop_idx + len(sig)] == sig:
+            skip = True
+        else:
+            skip = False
+    if not skip:
+        r += script[last_sop_idx:]
+    return CScript(r)
+
+
+def SignatureHash(script, txTo, inIdx, hashtype):
+    """Consensus-correct SignatureHash
+
+    Returns (hash, err) to precisely match the consensus-critical behavior of
+    the SIGHASH_SINGLE bug. (inIdx is *not* checked for validity)
+    """
+    HASH_ONE = b'\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+
+    if inIdx >= len(txTo.vin):
+        return (HASH_ONE, "inIdx %d out of range (%d)" % (inIdx, len(txTo.vin)))
+    txtmp = CTransaction(txTo)
+
+    for txin in txtmp.vin:
+        txin.scriptSig = b''
+    txtmp.vin[inIdx].scriptSig = FindAndDelete(script, CScript([OP_CODESEPARATOR]))
+
+    if (hashtype & 0x1f) == SIGHASH_NONE:
+        txtmp.vout = []
+
+        for i in range(len(txtmp.vin)):
+            if i != inIdx:
+                txtmp.vin[i].nSequence = 0
+
+    elif (hashtype & 0x1f) == SIGHASH_SINGLE:
+        outIdx = inIdx
+        if outIdx >= len(txtmp.vout):
+            return (HASH_ONE, "outIdx %d out of range (%d)" % (outIdx, len(txtmp.vout)))
+
+        tmp = txtmp.vout[outIdx]
+        txtmp.vout = []
+        for i in range(outIdx):
+            txtmp.vout.append(CTxOut(-1))
+        txtmp.vout.append(tmp)
+
+        for i in range(len(txtmp.vin)):
+            if i != inIdx:
+                txtmp.vin[i].nSequence = 0
+
+    if hashtype & SIGHASH_ANYONECANPAY:
+        tmp = txtmp.vin[inIdx]
+        txtmp.vin = []
+        txtmp.vin.append(tmp)
+
+    s = txtmp.serialize()
+    s += struct.pack(b"<I", hashtype)
+
+    hash = hash256(s)
+
+    return (hash, None)
+
+# TODO: Allow cached hashPrevouts/hashSequence/hashOutputs to be provided.
+# Performance optimization probably not necessary for python tests, however.
+# Note that this corresponds to sigversion == 1 in EvalScript, which is used
+# for version 0 witnesses.
+def SegwitVersion1SignatureHash(script, txTo, inIdx, hashtype, amount):
+
+    hashPrevouts = 0
+    hashSequence = 0
+    hashOutputs = 0
+
+    if not (hashtype & SIGHASH_ANYONECANPAY):
+        serialize_prevouts = bytes()
+        for i in txTo.vin:
+            serialize_prevouts += i.prevout.serialize()
+        hashPrevouts = uint256_from_str(hash256(serialize_prevouts))
+
+    if (not (hashtype & SIGHASH_ANYONECANPAY) and (hashtype & 0x1f) != SIGHASH_SINGLE and (hashtype & 0x1f) != SIGHASH_NONE):
+        serialize_sequence = bytes()
+        for i in txTo.vin:
+            serialize_sequence += struct.pack("<I", i.nSequence)
+        hashSequence = uint256_from_str(hash256(serialize_sequence))
+
+    if ((hashtype & 0x1f) != SIGHASH_SINGLE and (hashtype & 0x1f) != SIGHASH_NONE):
+        serialize_outputs = bytes()
+        for o in txTo.vout:
+            serialize_outputs += o.serialize()
+        hashOutputs = uint256_from_str(hash256(serialize_outputs))
+    elif ((hashtype & 0x1f) == SIGHASH_SINGLE and inIdx < len(txTo.vout)):
+        serialize_outputs = txTo.vout[inIdx].serialize()
+        hashOutputs = uint256_from_str(hash256(serialize_outputs))
+
+    ss = bytes()
+    ss += struct.pack("<i", txTo.nVersion)
+    ss += ser_uint256(hashPrevouts)
+    ss += ser_uint256(hashSequence)
+    ss += txTo.vin[inIdx].prevout.serialize()
+    ss += ser_string(script)
+    ss += struct.pack("<q", amount)
+    ss += struct.pack("<I", txTo.vin[inIdx].nSequence)
+    ss += ser_uint256(hashOutputs)
+    ss += struct.pack("<i", txTo.nLockTime)
+    ss += struct.pack("<I", hashtype)
+
+    return hash256(ss)

basicswap/interface/contrib/firo_test_framework/siphash.py

@@ -0,0 +1,64 @@
+#!/usr/bin/env python3
+# Copyright (c) 2016 The Bitcoin Core developers
+# Distributed under the MIT software license, see the accompanying
+# file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#
+# siphash.py - Specialized SipHash-2-4 implementations
+#
+# This implements SipHash-2-4 for 256-bit integers.
+
+def rotl64(n, b):
+    return n >> (64 - b) | (n & ((1 << (64 - b)) - 1)) << b
+
+def siphash_round(v0, v1, v2, v3):
+    v0 = (v0 + v1) & ((1 << 64) - 1)
+    v1 = rotl64(v1, 13)
+    v1 ^= v0
+    v0 = rotl64(v0, 32)
+    v2 = (v2 + v3) & ((1 << 64) - 1)
+    v3 = rotl64(v3, 16)
+    v3 ^= v2
+    v0 = (v0 + v3) & ((1 << 64) - 1)
+    v3 = rotl64(v3, 21)
+    v3 ^= v0
+    v2 = (v2 + v1) & ((1 << 64) - 1)
+    v1 = rotl64(v1, 17)
+    v1 ^= v2
+    v2 = rotl64(v2, 32)
+    return (v0, v1, v2, v3)
+
+def siphash256(k0, k1, h):
+    n0 = h & ((1 << 64) - 1)
+    n1 = (h >> 64) & ((1 << 64) - 1)
+    n2 = (h >> 128) & ((1 << 64) - 1)
+    n3 = (h >> 192) & ((1 << 64) - 1)
+    v0 = 0x736f6d6570736575 ^ k0
+    v1 = 0x646f72616e646f6d ^ k1
+    v2 = 0x6c7967656e657261 ^ k0
+    v3 = 0x7465646279746573 ^ k1 ^ n0
+    v0, v1, v2, v3 = siphash_round(v0, v1, v2, v3)
+    v0, v1, v2, v3 = siphash_round(v0, v1, v2, v3)
+    v0 ^= n0
+    v3 ^= n1
+    v0, v1, v2, v3 = siphash_round(v0, v1, v2, v3)
+    v0, v1, v2, v3 = siphash_round(v0, v1, v2, v3)
+    v0 ^= n1
+    v3 ^= n2
+    v0, v1, v2, v3 = siphash_round(v0, v1, v2, v3)
+    v0, v1, v2, v3 = siphash_round(v0, v1, v2, v3)
+    v0 ^= n2
+    v3 ^= n3
+    v0, v1, v2, v3 = siphash_round(v0, v1, v2, v3)
+    v0, v1, v2, v3 = siphash_round(v0, v1, v2, v3)
+    v0 ^= n3
+    v3 ^= 0x2000000000000000
+    v0, v1, v2, v3 = siphash_round(v0, v1, v2, v3)
+    v0, v1, v2, v3 = siphash_round(v0, v1, v2, v3)
+    v0 ^= 0x2000000000000000
+    v2 ^= 0xFF
+    v0, v1, v2, v3 = siphash_round(v0, v1, v2, v3)
+    v0, v1, v2, v3 = siphash_round(v0, v1, v2, v3)
+    v0, v1, v2, v3 = siphash_round(v0, v1, v2, v3)
+    v0, v1, v2, v3 = siphash_round(v0, v1, v2, v3)
+    return v0 ^ v1 ^ v2 ^ v3

basicswap/interface/contrib/firo_test_framework/util.py

@@ -0,0 +1,841 @@
+#!/usr/bin/env python3
+# Copyright (c) 2014-2016 The Bitcoin Core developers
+# Copyright (c) 2014-2017 The Dash Core developers
+# Distributed under the MIT software license, see the accompanying
+# file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+
+#
+# Helpful routines for regression testing
+#
+
+import os
+import sys
+
+from binascii import hexlify, unhexlify
+from base64 import b64encode
+from decimal import Decimal, ROUND_DOWN
+import json
+import http.client
+import random
+import shutil
+import subprocess
+import tempfile
+import time
+import re
+import errno
+import logging
+
+from . import coverage
+from .authproxy import AuthServiceProxy, JSONRPCException
+
+COVERAGE_DIR = None
+
+logger = logging.getLogger("TestFramework.utils")
+# The maximum number of nodes a single test can spawn
+MAX_NODES = 15
+# Don't assign rpc or p2p ports lower than this
+PORT_MIN = 11000
+# The number of ports to "reserve" for p2p and rpc, each
+PORT_RANGE = 5000
+
+BITCOIND_PROC_WAIT_TIMEOUT = 60
+
+
+class PortSeed:
+    # Must be initialized with a unique integer for each process
+    n = None
+
+#Set Mocktime default to OFF.
+#MOCKTIME is only needed for scripts that use the
+#cached version of the blockchain.  If the cached
+#version of the blockchain is used without MOCKTIME
+#then the mempools will not sync due to IBD.
+MOCKTIME = 0
+
+def enable_mocktime():
+    #For backwared compatibility of the python scripts
+    #with previous versions of the cache, set MOCKTIME
+    #to Jan 1, 2014 + (201 * 10 * 60)
+    global MOCKTIME
+    MOCKTIME = 1414776313 + (201 * 10 * 60)
+
+def set_mocktime(t):
+    global MOCKTIME
+    MOCKTIME = t
+
+def disable_mocktime():
+    global MOCKTIME
+    MOCKTIME = 0
+
+def get_mocktime():
+    return MOCKTIME
+
+def enable_coverage(dirname):
+    """Maintain a log of which RPC calls are made during testing."""
+    global COVERAGE_DIR
+    COVERAGE_DIR = dirname
+
+
+def get_rpc_proxy(url, node_number, timeout=None):
+    """
+    Args:
+        url (str): URL of the RPC server to call
+        node_number (int): the node number (or id) that this calls to
+
+    Kwargs:
+        timeout (int): HTTP timeout in seconds
+
+    Returns:
+        AuthServiceProxy. convenience object for making RPC calls.
+
+    """
+    proxy_kwargs = {}
+    if timeout is not None:
+        proxy_kwargs['timeout'] = timeout
+
+    proxy = AuthServiceProxy(url, **proxy_kwargs)
+    proxy.url = url  # store URL on proxy for info
+
+    coverage_logfile = coverage.get_filename(
+        COVERAGE_DIR, node_number) if COVERAGE_DIR else None
+
+    return coverage.AuthServiceProxyWrapper(proxy, coverage_logfile)
+
+def get_evoznsync_status(node):
+    result = node.evoznsync("status")
+    return result['IsSynced']
+
+def wait_to_sync(node, fast_znsync=False):
+    tm = 0
+    synced = False
+    while tm < 30:
+        synced = get_evoznsync_status(node)
+        if synced:
+            return
+        time.sleep(0.2)
+        if fast_znsync:
+            # skip mnsync states
+            node.evoznsync("next")
+        tm += 0.2
+    assert(synced)
+
+def p2p_port(n):
+    assert(n <= MAX_NODES)
+    return PORT_MIN + n + (MAX_NODES * PortSeed.n) % (PORT_RANGE - 1 - MAX_NODES)
+
+def rpc_port(n):
+    return PORT_MIN + PORT_RANGE + n + (MAX_NODES * PortSeed.n) % (PORT_RANGE - 1 - MAX_NODES)
+
+def check_json_precision():
+    """Make sure json library being used does not lose precision converting BTC values"""
+    n = Decimal("20000000.00000003")
+    satoshis = int(json.loads(json.dumps(float(n)))*1.0e8)
+    if satoshis != 2000000000000003:
+        raise RuntimeError("JSON encode/decode loses precision")
+
+def count_bytes(hex_string):
+    return len(bytearray.fromhex(hex_string))
+
+def bytes_to_hex_str(byte_str):
+    return hexlify(byte_str).decode('ascii')
+
+def hex_str_to_bytes(hex_str):
+    return unhexlify(hex_str.encode('ascii'))
+
+def str_to_b64str(string):
+    return b64encode(string.encode('utf-8')).decode('ascii')
+
+def sync_blocks(rpc_connections, *, wait=1, timeout=60):
+    """
+    Wait until everybody has the same tip.
+
+    sync_blocks needs to be called with an rpc_connections set that has least
+    one node already synced to the latest, stable tip, otherwise there's a
+    chance it might return before all nodes are stably synced.
+    """
+    # Use getblockcount() instead of waitforblockheight() to determine the
+    # initial max height because the two RPCs look at different internal global
+    # variables (chainActive vs latestBlock) and the former gets updated
+    # earlier.
+    maxheight = max(x.getblockcount() for x in rpc_connections)
+    start_time = cur_time = time.time()
+    while cur_time <= start_time + timeout:
+        tips = [r.waitforblockheight(maxheight, int(wait * 1000)) for r in rpc_connections]
+        if all(t["height"] == maxheight for t in tips):
+            if all(t["hash"] == tips[0]["hash"] for t in tips):
+                return
+            raise AssertionError("Block sync failed, mismatched block hashes:{}".format(
+                                 "".join("\n  {!r}".format(tip) for tip in tips)))
+
+        time.sleep(wait)
+        cur_time = time.time()
+    raise AssertionError("Block sync to height {} timed out:{}".format(
+                         maxheight, "".join("\n  {!r}".format(tip) for tip in tips)))
+
+def sync_znodes(rpc_connections, *, timeout=60):
+    """
+    Waits until every node has their znsync status is synced.
+    """
+    start_time = cur_time = time.time()
+    while cur_time <= start_time + timeout:
+        statuses = [r.znsync("status") for r in rpc_connections]
+        if all(stat["IsSynced"] == True for stat in statuses):
+            return
+        cur_time = time.time()
+    raise AssertionError("Znode sync failed.")
+
+def sync_chain(rpc_connections, *, wait=1, timeout=60):
+    """
+    Wait until everybody has the same best block
+    """
+    while timeout > 0:
+        best_hash = [x.getbestblockhash() for x in rpc_connections]
+        if best_hash == [best_hash[0]]*len(best_hash):
+            return
+        time.sleep(wait)
+        timeout -= wait
+    raise AssertionError("Chain sync failed: Best block hashes don't match")
+
+def sync_mempools(rpc_connections, *, wait=1, timeout=60):
+    """
+    Wait until everybody has the same transactions in their memory
+    pools
+    """
+    while timeout > 0:
+        pool = set(rpc_connections[0].getrawmempool())
+        num_match = 1
+        for i in range(1, len(rpc_connections)):
+            if set(rpc_connections[i].getrawmempool()) == pool:
+                num_match = num_match+1
+        if num_match == len(rpc_connections):
+            return
+        time.sleep(wait)
+        timeout -= wait
+    raise AssertionError("Mempool sync failed")
+
+def sync_znodes(rpc_connections, fast_mnsync=False):
+    for node in rpc_connections:
+        wait_to_sync(node, fast_mnsync)
+
+bitcoind_processes = {}
+
+def initialize_datadir(dirname, n):
+    datadir = os.path.join(dirname, "node"+str(n))
+    if not os.path.isdir(datadir):
+        os.makedirs(datadir)
+    rpc_u, rpc_p = rpc_auth_pair(n)
+    with open(os.path.join(datadir, "firo.conf"), 'w', encoding='utf8') as f:
+        f.write("regtest=1\n")
+        f.write("rpcuser=" + rpc_u + "\n")
+        f.write("rpcpassword=" + rpc_p + "\n")
+        f.write("port="+str(p2p_port(n))+"\n")
+        f.write("rpcport="+str(rpc_port(n))+"\n")
+        f.write("listenonion=0\n")
+    return datadir
+
+def rpc_auth_pair(n):
+    return 'rpcuser💻' + str(n), 'rpcpass🔑' + str(n)
+
+def rpc_url(i, rpchost=None):
+    rpc_u, rpc_p = rpc_auth_pair(i)
+    host = '127.0.0.1'
+    port = rpc_port(i)
+    if rpchost:
+        parts = rpchost.split(':')
+        if len(parts) == 2:
+            host, port = parts
+        else:
+            host = rpchost
+    return "http://%s:%s@%s:%d" % (rpc_u, rpc_p, host, int(port))
+
+def wait_for_bitcoind_start(process, url, i):
+    '''
+    Wait for firod to start. This means that RPC is accessible and fully initialized.
+    Raise an exception if firod exits during initialization.
+    '''
+    while True:
+        if process.poll() is not None:
+            raise Exception('firod exited with status %i during initialization' % process.returncode)
+        try:
+            rpc = get_rpc_proxy(url, i)
+            blocks = rpc.getblockcount()
+            break # break out of loop on success
+        except IOError as e:
+            if e.errno != errno.ECONNREFUSED: # Port not yet open?
+                raise # unknown IO error
+        except JSONRPCException as e: # Initialization phase
+            if e.error['code'] != -28: # RPC in warmup?
+                raise # unknown JSON RPC exception
+        time.sleep(0.25)
+
+def initialize_chain(test_dir, num_nodes, cachedir):
+    """
+    Create a cache of a 200-block-long chain (with wallet) for MAX_NODES
+    Afterward, create num_nodes copies from the cache
+    """
+
+    assert num_nodes <= MAX_NODES
+    create_cache = False
+    for i in range(MAX_NODES):
+        if not os.path.isdir(os.path.join(cachedir, 'node'+str(i))):
+            create_cache = True
+            break
+
+    if create_cache:
+
+        #find and delete old cache directories if any exist
+        for i in range(MAX_NODES):
+            if os.path.isdir(os.path.join(cachedir,"node"+str(i))):
+                shutil.rmtree(os.path.join(cachedir,"node"+str(i)))
+
+        # Create cache directories, run bitcoinds:
+        for i in range(MAX_NODES):
+            datadir=initialize_datadir(cachedir, i)
+            args = [ os.getenv("FIROD", "firod"), "-server", "-keypool=1", "-datadir="+datadir, "-discover=0" ]
+            if i > 0:
+                args.append("-connect=127.0.0.1:"+str(p2p_port(0)))
+            bitcoind_processes[i] = subprocess.Popen(args)
+            if os.getenv("PYTHON_DEBUG", ""):
+                print("initialize_chain: bitcoind started, waiting for RPC to come up")
+            wait_for_bitcoind_start(bitcoind_processes[i], rpc_url(i), i)
+            if os.getenv("PYTHON_DEBUG", ""):
+                print("initialize_chain: RPC successfully started")
+
+        rpcs = []
+        for i in range(MAX_NODES):
+            try:
+                rpcs.append(get_rpc_proxy(rpc_url(i), i))
+            except:
+                sys.stderr.write("Error connecting to "+url+"\n")
+                sys.exit(1)
+
+        # Create a 200-block-long chain; each of the 4 first nodes
+        # gets 25 mature blocks and 25 immature.
+        # Note: To preserve compatibility with older versions of
+        # initialize_chain, only 4 nodes will generate coins.
+        #
+        # blocks are created with timestamps 10 minutes apart
+        # starting from 2010 minutes in the past
+        enable_mocktime()
+        block_time = get_mocktime() - (201 * 10 * 60)
+        for i in range(2):
+            for peer in range(4):
+                for j in range(25):
+                    set_node_times(rpcs, block_time)
+                    rpcs[peer].generate(1)
+                    block_time += 10*60
+                # Must sync before next peer starts generating blocks
+                sync_blocks(rpcs)
+
+        # Shut them down, and clean up cache directories:
+        stop_nodes(rpcs)
+        disable_mocktime()
+        for i in range(MAX_NODES):
+            try:
+                os.remove(log_filename(cachedir, i, "debug.log"))
+                os.remove(log_filename(cachedir, i, "db.log"))
+                os.remove(log_filename(cachedir, i, "peers.dat"))
+                os.remove(log_filename(cachedir, i, "fee_estimates.dat"))
+            except OSError:
+                pass
+
+    for i in range(num_nodes):
+        from_dir = os.path.join(cachedir, "node"+str(i))
+        to_dir = os.path.join(test_dir,  "node"+str(i))
+        if from_dir != to_dir:
+            shutil.copytree(from_dir, to_dir)
+        initialize_datadir(test_dir, i) # Overwrite port/rpcport in bitcoin.conf
+
+def initialize_chain_clean(test_dir, num_nodes):
+    """
+    Create an empty blockchain and num_nodes wallets.
+    Useful if a test case wants complete control over initialization.
+    """
+    for i in range(num_nodes):
+        datadir=initialize_datadir(test_dir, i)
+
+
+def _rpchost_to_args(rpchost):
+    '''Convert optional IP:port spec to rpcconnect/rpcport args'''
+    if rpchost is None:
+        return []
+
+    match = re.match('(\[[0-9a-fA-f:]+\]|[^:]+)(?::([0-9]+))?$', rpchost)
+    if not match:
+        raise ValueError('Invalid RPC host spec ' + rpchost)
+
+    rpcconnect = match.group(1)
+    rpcport = match.group(2)
+
+    if rpcconnect.startswith('['): # remove IPv6 [...] wrapping
+        rpcconnect = rpcconnect[1:-1]
+
+    rv = ['-rpcconnect=' + rpcconnect]
+    if rpcport:
+        rv += ['-rpcport=' + rpcport]
+    return rv
+
+def start_node(i, dirname, extra_args=None, rpchost=None, timewait=None, binary=None, redirect_stderr=False, stderr=None):
+    """
+    Start a bitcoind and return RPC connection to it
+    """
+    datadir = os.path.join(dirname, "node"+str(i))
+    if binary is None:
+        binary = os.getenv("FIROD", "firod")
+    args = [ binary, "-datadir="+datadir, "-server", "-keypool=1", "-discover=0", "-rest", "-dandelion=0", "-usemnemonic=0", "-mocktime="+str(get_mocktime()) ]
+#Useful args for debugging
+#        "screen", "--",
+#        "gdb", "-x", "/tmp/gdb_run", "--args",
+
+# Don't try auto backups (they fail a lot when running tests)
+    args += [ "-createwalletbackups=0" ]
+    if extra_args is not None: args.extend(extra_args)
+    # Allow to redirect stderr to stdout in case we expect some non-critical warnings/errors printed to stderr
+    # Otherwise the whole test would be considered to be failed in such cases
+    if redirect_stderr:
+        stderr = sys.stdout
+    bitcoind_processes[i] = subprocess.Popen(args, stderr=stderr)
+    logger.debug("start_node: firod started, waiting for RPC to come up")
+    url = rpc_url(i, rpchost)
+    wait_for_bitcoind_start(bitcoind_processes[i], url, i)
+    logger.debug("start_node: RPC successfully started")
+    proxy = get_rpc_proxy(url, i, timeout=timewait)
+
+    if COVERAGE_DIR:
+        coverage.write_all_rpc_commands(COVERAGE_DIR, proxy)
+
+    return proxy
+
+def start_nodes(num_nodes, dirname, extra_args=None, rpchost=None, timewait=None, binary=None):
+    """
+    Start multiple bitcoinds, return RPC connections to them
+    """
+    if extra_args is None: extra_args = [ None for _ in range(num_nodes) ]
+    if binary is None: binary = [ None for _ in range(num_nodes) ]
+    rpcs = []
+    try:
+        for i in range(num_nodes):
+            rpcs.append(start_node(i, dirname, extra_args[i], rpchost, timewait=timewait, binary=binary[i]))
+    except: # If one node failed to start, stop the others
+        stop_nodes(rpcs)
+        raise
+    return rpcs
+
+def copy_datadir(from_node, to_node, dirname):
+    from_datadir = os.path.join(dirname, "node"+str(from_node), "regtest")
+    to_datadir = os.path.join(dirname, "node"+str(to_node), "regtest")
+
+    dirs = ["blocks", "chainstate", "evodb", "llmq"]
+    for d in dirs:
+        try:
+            src = os.path.join(from_datadir, d)
+            dst = os.path.join(to_datadir, d)
+            shutil.copytree(src, dst)
+        except:
+            pass
+def log_filename(dirname, n_node, logname):
+    return os.path.join(dirname, "node"+str(n_node), "regtest", logname)
+
+def wait_node(i):
+    return_code = bitcoind_processes[i].wait(timeout=BITCOIND_PROC_WAIT_TIMEOUT)
+    assert_equal(return_code, 0)
+    del bitcoind_processes[i]
+
+def stop_node(node, i, wait=True):
+    logger.debug("Stopping node %d" % i)
+    try:
+        node.stop()
+    except http.client.CannotSendRequest as e:
+        logger.exception("Unable to stop node")
+    if wait:
+        wait_node(i)
+
+def stop_nodes(nodes, fast=True):
+    for i, node in enumerate(nodes):
+        stop_node(node, i, not fast)
+    if fast:
+        for i, node in enumerate(nodes):
+            wait_node(i)
+    assert not bitcoind_processes.values() # All connections must be gone now
+
+def set_node_times(nodes, t):
+    for node in nodes:
+        node.setmocktime(t)
+
+def connect_nodes(from_connection, node_num):
+    # NOTE: In next line p2p_port(0) was replaced by rpc_port(0).
+    ip_port = "127.0.0.1:"+str(p2p_port(node_num))
+    from_connection.addnode(ip_port, "onetry")
+    # poll until version handshake complete to avoid race conditions
+    # with transaction relaying
+    while any(peer['version'] == 0 for peer in from_connection.getpeerinfo()):
+        time.sleep(0.1)
+
+def connect_nodes_bi(nodes, a, b):
+    connect_nodes(nodes[a], b)
+    connect_nodes(nodes[b], a)
+
+def isolate_node(node, timeout=5):
+    node.setnetworkactive(False)
+    st = time.time()
+    while time.time() < st + timeout:
+        if node.getconnectioncount() == 0:
+            return
+        time.sleep(0.5)
+    raise AssertionError("disconnect_node timed out")
+
+def reconnect_isolated_node(node, node_num):
+    node.setnetworkactive(True)
+    connect_nodes(node, node_num)
+def find_output(node, txid, amount):
+    """
+    Return index to output of txid with value amount
+    Raises exception if there is none.
+    """
+    txdata = node.getrawtransaction(txid, 1)
+    for i in range(len(txdata["vout"])):
+        if txdata["vout"][i]["value"] == amount:
+            return i
+    raise RuntimeError("find_output txid %s : %s not found"%(txid,str(amount)))
+
+
+def gather_inputs(from_node, amount_needed, confirmations_required=1):
+    """
+    Return a random set of unspent txouts that are enough to pay amount_needed
+    """
+    assert(confirmations_required >=0)
+    utxo = from_node.listunspent(confirmations_required)
+    random.shuffle(utxo)
+    inputs = []
+    total_in = Decimal("0.00000000")
+    while total_in < amount_needed and len(utxo) > 0:
+        t = utxo.pop()
+        total_in += t["amount"]
+        inputs.append({ "txid" : t["txid"], "vout" : t["vout"], "address" : t["address"] } )
+    if total_in < amount_needed:
+        raise RuntimeError("Insufficient funds: need %d, have %d"%(amount_needed, total_in))
+    return (total_in, inputs)
+
+def make_change(from_node, amount_in, amount_out, fee):
+    """
+    Create change output(s), return them
+    """
+    outputs = {}
+    amount = amount_out+fee
+    change = amount_in - amount
+    if change > amount*2:
+        # Create an extra change output to break up big inputs
+        change_address = from_node.getnewaddress()
+        # Split change in two, being careful of rounding:
+        outputs[change_address] = Decimal(change/2).quantize(Decimal('0.00000001'), rounding=ROUND_DOWN)
+        change = amount_in - amount - outputs[change_address]
+    if change > 0:
+        outputs[from_node.getnewaddress()] = change
+    return outputs
+
+def send_zeropri_transaction(from_node, to_node, amount, fee):
+    """
+    Create&broadcast a zero-priority transaction.
+    Returns (txid, hex-encoded-txdata)
+    Ensures transaction is zero-priority by first creating a send-to-self,
+    then using its output
+    """
+
+    # Create a send-to-self with confirmed inputs:
+    self_address = from_node.getnewaddress()
+    (total_in, inputs) = gather_inputs(from_node, amount+fee*2)
+    outputs = make_change(from_node, total_in, amount+fee, fee)
+    outputs[self_address] = float(amount+fee)
+
+    self_rawtx = from_node.createrawtransaction(inputs, outputs)
+    self_signresult = from_node.signrawtransaction(self_rawtx)
+    self_txid = from_node.sendrawtransaction(self_signresult["hex"], True)
+
+    vout = find_output(from_node, self_txid, amount+fee)
+    # Now immediately spend the output to create a 1-input, 1-output
+    # zero-priority transaction:
+    inputs = [ { "txid" : self_txid, "vout" : vout } ]
+    outputs = { to_node.getnewaddress() : float(amount) }
+
+    rawtx = from_node.createrawtransaction(inputs, outputs)
+    signresult = from_node.signrawtransaction(rawtx)
+    txid = from_node.sendrawtransaction(signresult["hex"], True)
+
+    return (txid, signresult["hex"])
+
+def random_zeropri_transaction(nodes, amount, min_fee, fee_increment, fee_variants):
+    """
+    Create a random zero-priority transaction.
+    Returns (txid, hex-encoded-transaction-data, fee)
+    """
+    from_node = random.choice(nodes)
+    to_node = random.choice(nodes)
+    fee = min_fee + fee_increment*random.randint(0,fee_variants)
+    (txid, txhex) = send_zeropri_transaction(from_node, to_node, amount, fee)
+    return (txid, txhex, fee)
+
+def random_transaction(nodes, amount, min_fee, fee_increment, fee_variants):
+    """
+    Create a random transaction.
+    Returns (txid, hex-encoded-transaction-data, fee)
+    """
+    from_node = random.choice(nodes)
+    to_node = random.choice(nodes)
+    fee = min_fee + fee_increment*random.randint(0,fee_variants)
+
+    (total_in, inputs) = gather_inputs(from_node, amount+fee)
+    outputs = make_change(from_node, total_in, amount, fee)
+    outputs[to_node.getnewaddress()] = float(amount)
+
+    rawtx = from_node.createrawtransaction(inputs, outputs)
+    signresult = from_node.signrawtransaction(rawtx)
+    txid = from_node.sendrawtransaction(signresult["hex"], True)
+
+    return (txid, signresult["hex"], fee)
+
+def assert_fee_amount(fee, tx_size, fee_per_kB):
+    """Assert the fee was in range"""
+    target_fee = tx_size * fee_per_kB / 1000
+    if fee < target_fee:
+        raise AssertionError("Fee of %s BTC too low! (Should be %s BTC)"%(str(fee), str(target_fee)))
+    # allow the wallet's estimation to be at most 2 bytes off
+    if fee > (tx_size + 2) * fee_per_kB / 1000:
+        raise AssertionError("Fee of %s BTC too high! (Should be %s BTC)"%(str(fee), str(target_fee)))
+
+def assert_equal(thing1, thing2, *args):
+    if thing1 != thing2 or any(thing1 != arg for arg in args):
+        raise AssertionError("not(%s)" % " == ".join(str(arg) for arg in (thing1, thing2) + args))
+
+def assert_greater_than(thing1, thing2):
+    if thing1 <= thing2:
+        raise AssertionError("%s <= %s"%(str(thing1),str(thing2)))
+
+def assert_greater_than_or_equal(thing1, thing2):
+    if thing1 < thing2:
+        raise AssertionError("%s < %s"%(str(thing1),str(thing2)))
+
+def assert_raises(exc, fun, *args, **kwds):
+    assert_raises_message(exc, None, fun, *args, **kwds)
+
+def assert_raises_message(exc, message, fun, *args, **kwds):
+    try:
+        fun(*args, **kwds)
+    except exc as e:
+        if message is not None and message not in e.error['message']:
+            raise AssertionError("Expected substring not found:"+e.error['message'])
+    except Exception as e:
+        raise AssertionError("Unexpected exception raised: "+type(e).__name__)
+    else:
+        raise AssertionError("No exception raised")
+
+def assert_raises_jsonrpc(code, message, fun, *args, **kwds):
+    """Run an RPC and verify that a specific JSONRPC exception code and message is raised.
+
+    Calls function `fun` with arguments `args` and `kwds`. Catches a JSONRPCException
+    and verifies that the error code and message are as expected. Throws AssertionError if
+    no JSONRPCException was returned or if the error code/message are not as expected.
+
+    Args:
+        code (int), optional: the error code returned by the RPC call (defined
+            in src/rpc/protocol.h). Set to None if checking the error code is not required.
+        message (string), optional: [a substring of] the error string returned by the
+            RPC call. Set to None if checking the error string is not required
+        fun (function): the function to call. This should be the name of an RPC.
+        args*: positional arguments for the function.
+        kwds**: named arguments for the function.
+    """
+    try:
+        fun(*args, **kwds)
+    except JSONRPCException as e:
+        # JSONRPCException was thrown as expected. Check the code and message values are correct.
+        if (code is not None) and (code != e.error["code"]):
+            raise AssertionError("Unexpected JSONRPC error code %i" % e.error["code"])
+        if (message is not None) and (message not in e.error['message']):
+            raise AssertionError("Expected substring not found:"+e.error['message'])
+    except Exception as e:
+        raise AssertionError("Unexpected exception raised: "+type(e).__name__)
+    else:
+        raise AssertionError("No exception raised")
+
+def assert_is_hex_string(string):
+    try:
+        int(string, 16)
+    except Exception as e:
+        raise AssertionError(
+            "Couldn't interpret %r as hexadecimal; raised: %s" % (string, e))
+
+def assert_is_hash_string(string, length=64):
+    if not isinstance(string, str):
+        raise AssertionError("Expected a string, got type %r" % type(string))
+    elif length and len(string) != length:
+        raise AssertionError(
+            "String of length %d expected; got %d" % (length, len(string)))
+    elif not re.match('[abcdef0-9]+$', string):
+        raise AssertionError(
+            "String %r contains invalid characters for a hash." % string)
+
+def assert_array_result(object_array, to_match, expected, should_not_find = False):
+    """
+        Pass in array of JSON objects, a dictionary with key/value pairs
+        to match against, and another dictionary with expected key/value
+        pairs.
+        If the should_not_find flag is true, to_match should not be found
+        in object_array
+        """
+    if should_not_find == True:
+        assert_equal(expected, { })
+    num_matched = 0
+    for item in object_array:
+        all_match = True
+        for key,value in to_match.items():
+            if item[key] != value:
+                all_match = False
+        if not all_match:
+            continue
+        elif should_not_find == True:
+            num_matched = num_matched+1
+        for key,value in expected.items():
+            if item[key] != value:
+                raise AssertionError("%s : expected %s=%s"%(str(item), str(key), str(value)))
+            num_matched = num_matched+1
+    if num_matched == 0 and should_not_find != True:
+        raise AssertionError("No objects matched %s"%(str(to_match)))
+    if num_matched > 0 and should_not_find == True:
+        raise AssertionError("Objects were found %s"%(str(to_match)))
+
+def satoshi_round(amount):
+    return Decimal(amount).quantize(Decimal('0.00000001'), rounding=ROUND_DOWN)
+
+# Helper to create at least "count" utxos
+# Pass in a fee that is sufficient for relay and mining new transactions.
+def create_confirmed_utxos(fee, node, count):
+    node.generate(int(0.5*count)+101)
+    utxos = node.listunspent()
+    iterations = count - len(utxos)
+    addr1 = node.getnewaddress()
+    addr2 = node.getnewaddress()
+    if iterations <= 0:
+        return utxos
+    for i in range(iterations):
+        t = utxos.pop()
+        inputs = []
+        inputs.append({ "txid" : t["txid"], "vout" : t["vout"]})
+        outputs = {}
+        send_value = t['amount'] - fee
+        outputs[addr1] = satoshi_round(send_value/2)
+        outputs[addr2] = satoshi_round(send_value/2)
+        raw_tx = node.createrawtransaction(inputs, outputs)
+        signed_tx = node.signrawtransaction(raw_tx)["hex"]
+        txid = node.sendrawtransaction(signed_tx)
+
+    while (node.getmempoolinfo()['size'] > 0):
+        node.generate(1)
+
+    utxos = node.listunspent()
+    assert(len(utxos) >= count)
+    return utxos
+
+# Create large OP_RETURN txouts that can be appended to a transaction
+# to make it large (helper for constructing large transactions).
+def gen_return_txouts():
+    # Some pre-processing to create a bunch of OP_RETURN txouts to insert into transactions we create
+    # So we have big transactions (and therefore can't fit very many into each block)
+    # create one script_pubkey
+    script_pubkey = "6a4d0200" #OP_RETURN OP_PUSH2 512 bytes
+    for i in range (512):
+        script_pubkey = script_pubkey + "01"
+    # concatenate 128 txouts of above script_pubkey which we'll insert before the txout for change
+    txouts = "81"
+    for k in range(128):
+        # add txout value
+        txouts = txouts + "0000000000000000"
+        # add length of script_pubkey
+        txouts = txouts + "fd0402"
+        # add script_pubkey
+        txouts = txouts + script_pubkey
+    return txouts
+
+def create_tx(node, coinbase, to_address, amount):
+    inputs = [{ "txid" : coinbase, "vout" : 0}]
+    outputs = { to_address : amount }
+    rawtx = node.createrawtransaction(inputs, outputs)
+    signresult = node.signrawtransaction(rawtx)
+    assert_equal(signresult["complete"], True)
+    return signresult["hex"]
+
+def create_tx_multi_input(node, inputs, outputs):
+    rawtx = node.createrawtransaction(inputs, outputs)
+    signresult = node.signrawtransaction(rawtx)
+    assert_equal(signresult["complete"], True)
+    return signresult["hex"]
+
+# Create a spend of each passed-in utxo, splicing in "txouts" to each raw
+# transaction to make it large.  See gen_return_txouts() above.
+def create_lots_of_big_transactions(node, txouts, utxos, num, fee):
+    addr = node.getnewaddress()
+    txids = []
+    for _ in range(num):
+        t = utxos.pop()
+        inputs=[{ "txid" : t["txid"], "vout" : t["vout"]}]
+        outputs = {}
+        change = t['amount'] - fee
+        outputs[addr] = satoshi_round(change)
+        rawtx = node.createrawtransaction(inputs, outputs)
+        newtx = rawtx[0:92]
+        newtx = newtx + txouts
+        newtx = newtx + rawtx[94:]
+        signresult = node.signrawtransaction(newtx, None, None, "NONE")
+        txid = node.sendrawtransaction(signresult["hex"], True)
+        txids.append(txid)
+    return txids
+
+def mine_large_block(node, utxos=None):
+    # generate a 66k transaction,
+    # and 14 of them is close to the 1MB block limit
+    num = 14
+    txouts = gen_return_txouts()
+    utxos = utxos if utxos is not None else []
+    if len(utxos) < num:
+        utxos.clear()
+        utxos.extend(node.listunspent())
+    fee = 100 * node.getnetworkinfo()["relayfee"]
+    create_lots_of_big_transactions(node, txouts, utxos, num, fee=fee)
+    node.generate(1)
+
+def get_bip9_status(node, key):
+    info = node.getblockchaininfo()
+    return info['bip9_softforks'][key]
+
+def dumpprivkey_otac(node, address):
+    import re
+    error_text = ''
+    try:
+        return node.dumpprivkey(address)
+    except JSONRPCException as e:
+        error_text = e.error
+    else:
+        raise
+
+    otac_match = re.search("Your one time authorization code is: ([a-zA-Z0-9]+)", error_text['message'])
+    if not otac_match:
+        raise JSONRPCException(error_text)
+    return node.dumpprivkey(address, otac_match.groups()[0])
+
+def get_znsync_status(node):
+    result = node.znsync("status")
+    return result['IsSynced']
+
+def wait_to_sync_znodes(node, fast_znsync=False):
+    while True:
+        synced = get_znsync_status(node)
+        if synced:
+            break
+        time.sleep(0.2)
+        if fast_znsync:
+            # skip mnsync states
+            node.znsync("next")
+
+def get_full_balance(node):
+    wallet_info = node.getwalletinfo()
+    return wallet_info["balance"] + wallet_info["immature_balance"] + wallet_info["unconfirmed_balance"]

basicswap/interface/contrib/nav_test_framework/authproxy.py

@@ -0,0 +1,175 @@
+
+"""
+  Copyright 2011 Jeff Garzik
+
+  AuthServiceProxy has the following improvements over python-jsonrpc's
+  ServiceProxy class:
+
+  - HTTP connections persist for the life of the AuthServiceProxy object
+    (if server supports HTTP/1.1)
+  - sends protocol 'version', per JSON-RPC 1.1
+  - sends proper, incrementing 'id'
+  - sends Basic HTTP authentication headers
+  - parses all JSON numbers that look like floats as Decimal
+  - uses standard Python json lib
+
+  Previous copyright, from python-jsonrpc/jsonrpc/proxy.py:
+
+  Copyright (c) 2007 Jan-Klaas Kollhof
+
+  This file is part of jsonrpc.
+
+  jsonrpc is free software; you can redistribute it and/or modify
+  it under the terms of the GNU Lesser General Public License as published by
+  the Free Software Foundation; either version 2.1 of the License, or
+  (at your option) any later version.
+
+  This software is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General Public License
+  along with this software; if not, write to the Free Software
+  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+"""
+
+try:
+    import http.client as httplib
+except ImportError:
+    import httplib
+import base64
+import decimal
+import json
+import logging
+try:
+    import urllib.parse as urlparse
+except ImportError:
+    import urlparse
+
+USER_AGENT = "AuthServiceProxy/0.1"
+
+HTTP_TIMEOUT = 30
+
+log = logging.getLogger("NavcoinRPC")
+
+class JSONRPCException(Exception):
+    def __init__(self, rpc_error):
+        Exception.__init__(self)
+        self.error = rpc_error
+
+
+def EncodeDecimal(o):
+    if isinstance(o, decimal.Decimal):
+        return str(o)
+    raise TypeError(repr(o) + " is not JSON serializable")
+
+class AuthServiceProxy(object):
+    __id_count = 0
+
+    # ensure_ascii: escape unicode as \uXXXX, passed to json.dumps
+    def __init__(self, service_url, service_name=None, timeout=HTTP_TIMEOUT, connection=None, ensure_ascii=True):
+        self.__service_url = service_url
+        self._service_name = service_name
+        self.ensure_ascii = ensure_ascii # can be toggled on the fly by tests
+        self.__url = urlparse.urlparse(service_url)
+        if self.__url.port is None:
+            port = 80
+        else:
+            port = self.__url.port
+        (user, passwd) = (self.__url.username, self.__url.password)
+        try:
+            user = user.encode('utf8')
+        except AttributeError:
+            pass
+        try:
+            passwd = passwd.encode('utf8')
+        except AttributeError:
+            pass
+        authpair = user + b':' + passwd
+        self.__auth_header = b'Basic ' + base64.b64encode(authpair)
+
+        if connection:
+            # Callables re-use the connection of the original proxy
+            self.__conn = connection
+        elif self.__url.scheme == 'https':
+            self.__conn = httplib.HTTPSConnection(self.__url.hostname, port,
+                                                  timeout=timeout)
+        else:
+            self.__conn = httplib.HTTPConnection(self.__url.hostname, port,
+                                                 timeout=timeout)
+
+    def __getattr__(self, name):
+        if name.startswith('__') and name.endswith('__'):
+            # Python internal stuff
+            raise AttributeError
+        if self._service_name is not None:
+            name = "%s.%s" % (self._service_name, name)
+        return AuthServiceProxy(self.__service_url, name, connection=self.__conn)
+
+    def _request(self, method, path, postdata):
+        '''
+        Do a HTTP request, with retry if we get disconnected (e.g. due to a timeout).
+        This is a workaround for https://bugs.python.org/issue3566 which is fixed in Python 3.5.
+        '''
+        headers = {'Host': self.__url.hostname,
+                   'User-Agent': USER_AGENT,
+                   'Authorization': self.__auth_header,
+                   'Content-type': 'application/json'}
+        try:
+            self.__conn.request(method, path, postdata, headers)
+            return self._get_response()
+        except httplib.BadStatusLine as e:
+            if e.line == "''": # if connection was closed, try again
+                self.__conn.close()
+                self.__conn.request(method, path, postdata, headers)
+                return self._get_response()
+            else:
+                raise
+        except BrokenPipeError:
+            # Python 3.5+ raises this instead of BadStatusLine when the connection was reset
+            self.__conn.close()
+            self.__conn.request(method, path, postdata, headers)
+            return self._get_response()
+
+    def __call__(self, *args):
+        AuthServiceProxy.__id_count += 1
+
+        log.debug("-%s-> %s %s"%(AuthServiceProxy.__id_count, self._service_name,
+                                 json.dumps(args, default=EncodeDecimal, ensure_ascii=self.ensure_ascii)))
+        postdata = json.dumps({'version': '1.1',
+                               'method': self._service_name,
+                               'params': args,
+                               'id': AuthServiceProxy.__id_count}, default=EncodeDecimal, ensure_ascii=self.ensure_ascii)
+        response = self._request('POST', self.__url.path, postdata.encode('utf-8'))
+        if response['error'] is not None:
+            raise JSONRPCException(response['error'])
+        elif 'result' not in response:
+            raise JSONRPCException({
+                'code': -343, 'message': 'missing JSON-RPC result'})
+        else:
+            return response['result']
+
+    def _batch(self, rpc_call_list):
+        postdata = json.dumps(list(rpc_call_list), default=EncodeDecimal, ensure_ascii=self.ensure_ascii)
+        log.debug("--> "+postdata)
+        return self._request('POST', self.__url.path, postdata.encode('utf-8'))
+
+    def _get_response(self):
+        http_response = self.__conn.getresponse()
+        if http_response is None:
+            raise JSONRPCException({
+                'code': -342, 'message': 'missing HTTP response from server'})
+
+        content_type = http_response.getheader('Content-Type')
+        if content_type != 'application/json':
+            raise JSONRPCException({
+                'code': -342, 'message': 'non-JSON HTTP response with \'%i %s\' from server' % (http_response.status, http_response.reason)})
+
+        responsedata = http_response.read().decode('utf8')
+        response = json.loads(responsedata, parse_float=decimal.Decimal)
+        if "error" in response and response["error"] is None:
+            log.debug("<-%s- %s"%(response["id"], json.dumps(response["result"], default=EncodeDecimal, ensure_ascii=self.ensure_ascii)))
+        else:
+            log.debug("<-- "+responsedata)
+        return response

basicswap/interface/contrib/nav_test_framework/bignum.py

@@ -0,0 +1,101 @@
+#!/usr/bin/env python3
+#
+# bignum.py
+#
+# This file is copied from python-navcoinlib.
+#
+# Distributed under the MIT software license, see the accompanying
+# file COPYING or http://www.opensource.org/licenses/mit-license.php.
+#
+
+"""Bignum routines"""
+
+
+import struct
+
+
+# generic big endian MPI format
+
+def bn_bytes(v, have_ext=False):
+    ext = 0
+    if have_ext:
+        ext = 1
+    return ((v.bit_length()+7)//8) + ext
+
+def bn2bin(v):
+    s = bytearray()
+    i = bn_bytes(v)
+    while i > 0:
+        s.append((v >> ((i-1) * 8)) & 0xff)
+        i -= 1
+    return s
+
+def bin2bn(s):
+    l = 0
+    for ch in s:
+        l = (l << 8) | ch
+    return l
+
+def bn2mpi(v):
+    have_ext = False
+    if v.bit_length() > 0:
+        have_ext = (v.bit_length() & 0x07) == 0
+
+    neg = False
+    if v < 0:
+        neg = True
+        v = -v
+
+    s = struct.pack(b">I", bn_bytes(v, have_ext))
+    ext = bytearray()
+    if have_ext:
+        ext.append(0)
+    v_bin = bn2bin(v)
+    if neg:
+        if have_ext:
+            ext[0] |= 0x80
+        else:
+            v_bin[0] |= 0x80
+    return s + ext + v_bin
+
+def mpi2bn(s):
+    if len(s) < 4:
+        return None
+    s_size = bytes(s[:4])
+    v_len = struct.unpack(b">I", s_size)[0]
+    if len(s) != (v_len + 4):
+        return None
+    if v_len == 0:
+        return 0
+
+    v_str = bytearray(s[4:])
+    neg = False
+    i = v_str[0]
+    if i & 0x80:
+        neg = True
+        i &= ~0x80
+        v_str[0] = i
+
+    v = bin2bn(v_str)
+
+    if neg:
+        return -v
+    return v
+
+# navcoin-specific little endian format, with implicit size
+def mpi2vch(s):
+    r = s[4:]           # strip size
+    r = r[::-1]         # reverse string, converting BE->LE
+    return r
+
+def bn2vch(v):
+    return bytes(mpi2vch(bn2mpi(v)))
+
+def vch2mpi(s):
+    r = struct.pack(b">I", len(s))   # size
+    r += s[::-1]            # reverse string, converting LE->BE
+    return r
+
+def vch2bn(s):
+    return mpi2bn(vch2mpi(s))
+

basicswap/interface/contrib/nav_test_framework/coverage.py

@@ -0,0 +1,106 @@
+#!/usr/bin/env python3
+# Copyright (c) 2015-2016 The Bitcoin Core developers
+# Distributed under the MIT software license, see the accompanying
+# file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+"""
+This module contains utilities for doing coverage analysis on the RPC
+interface.
+
+It provides a way to track which RPC commands are exercised during
+testing.
+
+"""
+import os
+
+
+REFERENCE_FILENAME = 'rpc_interface.txt'
+
+
+class AuthServiceProxyWrapper(object):
+    """
+    An object that wraps AuthServiceProxy to record specific RPC calls.
+
+    """
+    def __init__(self, auth_service_proxy_instance, coverage_logfile=None):
+        """
+        Kwargs:
+            auth_service_proxy_instance (AuthServiceProxy): the instance
+                being wrapped.
+            coverage_logfile (str): if specified, write each service_name
+                out to a file when called.
+
+        """
+        self.auth_service_proxy_instance = auth_service_proxy_instance
+        self.coverage_logfile = coverage_logfile
+
+    def __getattr__(self, *args, **kwargs):
+        return_val = self.auth_service_proxy_instance.__getattr__(
+            *args, **kwargs)
+
+        return AuthServiceProxyWrapper(return_val, self.coverage_logfile)
+
+    def __call__(self, *args, **kwargs):
+        """
+        Delegates to AuthServiceProxy, then writes the particular RPC method
+        called to a file.
+
+        """
+        return_val = self.auth_service_proxy_instance.__call__(*args, **kwargs)
+        rpc_method = self.auth_service_proxy_instance._service_name
+
+        if self.coverage_logfile:
+            with open(self.coverage_logfile, 'a+') as f:
+                f.write("%s\n" % rpc_method)
+
+        return return_val
+
+    @property
+    def url(self):
+        return self.auth_service_proxy_instance.url
+
+
+def get_filename(dirname, n_node):
+    """
+    Get a filename unique to the test process ID and node.
+
+    This file will contain a list of RPC commands covered.
+    """
+    pid = str(os.getpid())
+    return os.path.join(
+        dirname, "coverage.pid%s.node%s.txt" % (pid, str(n_node)))
+
+
+def write_all_rpc_commands(dirname, node):
+    """
+    Write out a list of all RPC functions available in `navcoin-cli` for
+    coverage comparison. This will only happen once per coverage
+    directory.
+
+    Args:
+        dirname (str): temporary test dir
+        node (AuthServiceProxy): client
+
+    Returns:
+        bool. if the RPC interface file was written.
+
+    """
+    filename = os.path.join(dirname, REFERENCE_FILENAME)
+
+    if os.path.isfile(filename):
+        return False
+
+    help_output = node.help().split('\n')
+    commands = set()
+
+    for line in help_output:
+        line = line.strip()
+
+        # Ignore blanks and headers
+        if line and not line.startswith('='):
+            commands.add("%s\n" % line.split()[0])
+
+    with open(filename, 'w') as f:
+        f.writelines(list(commands))
+
+    return True

basicswap/interface/contrib/nav_test_framework/script.py

@@ -0,0 +1,943 @@
+#!/usr/bin/env python3
+# Copyright (c) 2015-2016 The Bitcoin Core developers
+# Distributed under the MIT software license, see the accompanying
+# file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#
+# script.py
+#
+# This file is modified from python-navcoinlib.
+#
+
+"""Scripts
+
+Functionality to build scripts, as well as SignatureHash().
+"""
+
+
+from .mininode import CTransaction, CTxOut, sha256, hash256, uint256_from_str, ser_uint256, ser_string
+from binascii import hexlify
+import hashlib
+
+import sys
+bchr = chr
+bord = ord
+if sys.version > '3':
+    long = int
+    bchr = lambda x: bytes([x])
+    bord = lambda x: x
+
+import struct
+
+from .bignum import bn2vch
+
+MAX_SCRIPT_SIZE = 10000
+MAX_SCRIPT_ELEMENT_SIZE = 520
+MAX_SCRIPT_OPCODES = 201
+
+OPCODE_NAMES = {}
+
+_opcode_instances = []
+class CScriptOp(int):
+    """A single script opcode"""
+    __slots__ = []
+
+    @staticmethod
+    def encode_op_pushdata(d):
+        """Encode a PUSHDATA op, returning bytes"""
+        if len(d) < 0x4c:
+            return b'' + bchr(len(d)) + d # OP_PUSHDATA
+        elif len(d) <= 0xff:
+            return b'\x4c' + bchr(len(d)) + d # OP_PUSHDATA1
+        elif len(d) <= 0xffff:
+            return b'\x4d' + struct.pack(b'<H', len(d)) + d # OP_PUSHDATA2
+        elif len(d) <= 0xffffffff:
+            return b'\x4e' + struct.pack(b'<I', len(d)) + d # OP_PUSHDATA4
+        else:
+            raise ValueError("Data too long to encode in a PUSHDATA op")
+
+    @staticmethod
+    def encode_op_n(n):
+        """Encode a small integer op, returning an opcode"""
+        if not (0 <= n <= 16):
+            raise ValueError('Integer must be in range 0 <= n <= 16, got %d' % n)
+
+        if n == 0:
+            return OP_0
+        else:
+            return CScriptOp(OP_1 + n-1)
+
+    def decode_op_n(self):
+        """Decode a small integer opcode, returning an integer"""
+        if self == OP_0:
+            return 0
+
+        if not (self == OP_0 or OP_1 <= self <= OP_16):
+            raise ValueError('op %r is not an OP_N' % self)
+
+        return int(self - OP_1+1)
+
+    def is_small_int(self):
+        """Return true if the op pushes a small integer to the stack"""
+        if 0x51 <= self <= 0x60 or self == 0:
+            return True
+        else:
+            return False
+
+    def __str__(self):
+        return repr(self)
+
+    def __repr__(self):
+        if self in OPCODE_NAMES:
+            return OPCODE_NAMES[self]
+        else:
+            return 'CScriptOp(0x%x)' % self
+
+    def __new__(cls, n):
+        try:
+            return _opcode_instances[n]
+        except IndexError:
+            assert len(_opcode_instances) == n
+            _opcode_instances.append(super(CScriptOp, cls).__new__(cls, n))
+            return _opcode_instances[n]
+
+# Populate opcode instance table
+for n in range(0xff+1):
+    CScriptOp(n)
+
+
+# push value
+OP_0 = CScriptOp(0x00)
+OP_FALSE = OP_0
+OP_PUSHDATA1 = CScriptOp(0x4c)
+OP_PUSHDATA2 = CScriptOp(0x4d)
+OP_PUSHDATA4 = CScriptOp(0x4e)
+OP_1NEGATE = CScriptOp(0x4f)
+OP_RESERVED = CScriptOp(0x50)
+OP_1 = CScriptOp(0x51)
+OP_TRUE=OP_1
+OP_2 = CScriptOp(0x52)
+OP_3 = CScriptOp(0x53)
+OP_4 = CScriptOp(0x54)
+OP_5 = CScriptOp(0x55)
+OP_6 = CScriptOp(0x56)
+OP_7 = CScriptOp(0x57)
+OP_8 = CScriptOp(0x58)
+OP_9 = CScriptOp(0x59)
+OP_10 = CScriptOp(0x5a)
+OP_11 = CScriptOp(0x5b)
+OP_12 = CScriptOp(0x5c)
+OP_13 = CScriptOp(0x5d)
+OP_14 = CScriptOp(0x5e)
+OP_15 = CScriptOp(0x5f)
+OP_16 = CScriptOp(0x60)
+
+# control
+OP_NOP = CScriptOp(0x61)
+OP_VER = CScriptOp(0x62)
+OP_IF = CScriptOp(0x63)
+OP_NOTIF = CScriptOp(0x64)
+OP_VERIF = CScriptOp(0x65)
+OP_VERNOTIF = CScriptOp(0x66)
+OP_ELSE = CScriptOp(0x67)
+OP_ENDIF = CScriptOp(0x68)
+OP_VERIFY = CScriptOp(0x69)
+OP_RETURN = CScriptOp(0x6a)
+
+# stack ops
+OP_TOALTSTACK = CScriptOp(0x6b)
+OP_FROMALTSTACK = CScriptOp(0x6c)
+OP_2DROP = CScriptOp(0x6d)
+OP_2DUP = CScriptOp(0x6e)
+OP_3DUP = CScriptOp(0x6f)
+OP_2OVER = CScriptOp(0x70)
+OP_2ROT = CScriptOp(0x71)
+OP_2SWAP = CScriptOp(0x72)
+OP_IFDUP = CScriptOp(0x73)
+OP_DEPTH = CScriptOp(0x74)
+OP_DROP = CScriptOp(0x75)
+OP_DUP = CScriptOp(0x76)
+OP_NIP = CScriptOp(0x77)
+OP_OVER = CScriptOp(0x78)
+OP_PICK = CScriptOp(0x79)
+OP_ROLL = CScriptOp(0x7a)
+OP_ROT = CScriptOp(0x7b)
+OP_SWAP = CScriptOp(0x7c)
+OP_TUCK = CScriptOp(0x7d)
+
+# splice ops
+OP_CAT = CScriptOp(0x7e)
+OP_SUBSTR = CScriptOp(0x7f)
+OP_LEFT = CScriptOp(0x80)
+OP_RIGHT = CScriptOp(0x81)
+OP_SIZE = CScriptOp(0x82)
+
+# bit logic
+OP_INVERT = CScriptOp(0x83)
+OP_AND = CScriptOp(0x84)
+OP_OR = CScriptOp(0x85)
+OP_XOR = CScriptOp(0x86)
+OP_EQUAL = CScriptOp(0x87)
+OP_EQUALVERIFY = CScriptOp(0x88)
+OP_RESERVED1 = CScriptOp(0x89)
+OP_RESERVED2 = CScriptOp(0x8a)
+
+# numeric
+OP_1ADD = CScriptOp(0x8b)
+OP_1SUB = CScriptOp(0x8c)
+OP_2MUL = CScriptOp(0x8d)
+OP_2DIV = CScriptOp(0x8e)
+OP_NEGATE = CScriptOp(0x8f)
+OP_ABS = CScriptOp(0x90)
+OP_NOT = CScriptOp(0x91)
+OP_0NOTEQUAL = CScriptOp(0x92)
+
+OP_ADD = CScriptOp(0x93)
+OP_SUB = CScriptOp(0x94)
+OP_MUL = CScriptOp(0x95)
+OP_DIV = CScriptOp(0x96)
+OP_MOD = CScriptOp(0x97)
+OP_LSHIFT = CScriptOp(0x98)
+OP_RSHIFT = CScriptOp(0x99)
+
+OP_BOOLAND = CScriptOp(0x9a)
+OP_BOOLOR = CScriptOp(0x9b)
+OP_NUMEQUAL = CScriptOp(0x9c)
+OP_NUMEQUALVERIFY = CScriptOp(0x9d)
+OP_NUMNOTEQUAL = CScriptOp(0x9e)
+OP_LESSTHAN = CScriptOp(0x9f)
+OP_GREATERTHAN = CScriptOp(0xa0)
+OP_LESSTHANOREQUAL = CScriptOp(0xa1)
+OP_GREATERTHANOREQUAL = CScriptOp(0xa2)
+OP_MIN = CScriptOp(0xa3)
+OP_MAX = CScriptOp(0xa4)
+
+OP_WITHIN = CScriptOp(0xa5)
+
+# crypto
+OP_RIPEMD160 = CScriptOp(0xa6)
+OP_SHA1 = CScriptOp(0xa7)
+OP_SHA256 = CScriptOp(0xa8)
+OP_HASH160 = CScriptOp(0xa9)
+OP_HASH256 = CScriptOp(0xaa)
+OP_CODESEPARATOR = CScriptOp(0xab)
+OP_CHECKSIG = CScriptOp(0xac)
+OP_CHECKSIGVERIFY = CScriptOp(0xad)
+OP_CHECKMULTISIG = CScriptOp(0xae)
+OP_CHECKMULTISIGVERIFY = CScriptOp(0xaf)
+
+# expansion
+OP_NOP1 = CScriptOp(0xb0)
+OP_CHECKLOCKTIMEVERIFY = CScriptOp(0xb1)
+OP_CHECKSEQUENCEVERIFY = CScriptOp(0xb2)
+OP_NOP4 = CScriptOp(0xb3)
+OP_NOP5 = CScriptOp(0xb4)
+OP_NOP6 = CScriptOp(0xb5)
+OP_NOP7 = CScriptOp(0xb6)
+OP_NOP8 = CScriptOp(0xb7)
+OP_NOP9 = CScriptOp(0xb8)
+OP_NOP10 = CScriptOp(0xb9)
+
+# template matching params
+OP_SMALLINTEGER = CScriptOp(0xfa)
+OP_PUBKEYS = CScriptOp(0xfb)
+OP_PUBKEYHASH = CScriptOp(0xfd)
+OP_PUBKEY = CScriptOp(0xfe)
+
+OP_INVALIDOPCODE = CScriptOp(0xff)
+
+VALID_OPCODES = {
+    OP_1NEGATE,
+    OP_RESERVED,
+    OP_1,
+    OP_2,
+    OP_3,
+    OP_4,
+    OP_5,
+    OP_6,
+    OP_7,
+    OP_8,
+    OP_9,
+    OP_10,
+    OP_11,
+    OP_12,
+    OP_13,
+    OP_14,
+    OP_15,
+    OP_16,
+
+    OP_NOP,
+    OP_VER,
+    OP_IF,
+    OP_NOTIF,
+    OP_VERIF,
+    OP_VERNOTIF,
+    OP_ELSE,
+    OP_ENDIF,
+    OP_VERIFY,
+    OP_RETURN,
+
+    OP_TOALTSTACK,
+    OP_FROMALTSTACK,
+    OP_2DROP,
+    OP_2DUP,
+    OP_3DUP,
+    OP_2OVER,
+    OP_2ROT,
+    OP_2SWAP,
+    OP_IFDUP,
+    OP_DEPTH,
+    OP_DROP,
+    OP_DUP,
+    OP_NIP,
+    OP_OVER,
+    OP_PICK,
+    OP_ROLL,
+    OP_ROT,
+    OP_SWAP,
+    OP_TUCK,
+
+    OP_CAT,
+    OP_SUBSTR,
+    OP_LEFT,
+    OP_RIGHT,
+    OP_SIZE,
+
+    OP_INVERT,
+    OP_AND,
+    OP_OR,
+    OP_XOR,
+    OP_EQUAL,
+    OP_EQUALVERIFY,
+    OP_RESERVED1,
+    OP_RESERVED2,
+
+    OP_1ADD,
+    OP_1SUB,
+    OP_2MUL,
+    OP_2DIV,
+    OP_NEGATE,
+    OP_ABS,
+    OP_NOT,
+    OP_0NOTEQUAL,
+
+    OP_ADD,
+    OP_SUB,
+    OP_MUL,
+    OP_DIV,
+    OP_MOD,
+    OP_LSHIFT,
+    OP_RSHIFT,
+
+    OP_BOOLAND,
+    OP_BOOLOR,
+    OP_NUMEQUAL,
+    OP_NUMEQUALVERIFY,
+    OP_NUMNOTEQUAL,
+    OP_LESSTHAN,
+    OP_GREATERTHAN,
+    OP_LESSTHANOREQUAL,
+    OP_GREATERTHANOREQUAL,
+    OP_MIN,
+    OP_MAX,
+
+    OP_WITHIN,
+
+    OP_RIPEMD160,
+    OP_SHA1,
+    OP_SHA256,
+    OP_HASH160,
+    OP_HASH256,
+    OP_CODESEPARATOR,
+    OP_CHECKSIG,
+    OP_CHECKSIGVERIFY,
+    OP_CHECKMULTISIG,
+    OP_CHECKMULTISIGVERIFY,
+
+    OP_NOP1,
+    OP_CHECKLOCKTIMEVERIFY,
+    OP_CHECKSEQUENCEVERIFY,
+    OP_NOP4,
+    OP_NOP5,
+    OP_NOP6,
+    OP_NOP7,
+    OP_NOP8,
+    OP_NOP9,
+    OP_NOP10,
+
+    OP_SMALLINTEGER,
+    OP_PUBKEYS,
+    OP_PUBKEYHASH,
+    OP_PUBKEY,
+}
+
+OPCODE_NAMES.update({
+    OP_0 : 'OP_0',
+    OP_PUSHDATA1 : 'OP_PUSHDATA1',
+    OP_PUSHDATA2 : 'OP_PUSHDATA2',
+    OP_PUSHDATA4 : 'OP_PUSHDATA4',
+    OP_1NEGATE : 'OP_1NEGATE',
+    OP_RESERVED : 'OP_RESERVED',
+    OP_1 : 'OP_1',
+    OP_2 : 'OP_2',
+    OP_3 : 'OP_3',
+    OP_4 : 'OP_4',
+    OP_5 : 'OP_5',
+    OP_6 : 'OP_6',
+    OP_7 : 'OP_7',
+    OP_8 : 'OP_8',
+    OP_9 : 'OP_9',
+    OP_10 : 'OP_10',
+    OP_11 : 'OP_11',
+    OP_12 : 'OP_12',
+    OP_13 : 'OP_13',
+    OP_14 : 'OP_14',
+    OP_15 : 'OP_15',
+    OP_16 : 'OP_16',
+    OP_NOP : 'OP_NOP',
+    OP_VER : 'OP_VER',
+    OP_IF : 'OP_IF',
+    OP_NOTIF : 'OP_NOTIF',
+    OP_VERIF : 'OP_VERIF',
+    OP_VERNOTIF : 'OP_VERNOTIF',
+    OP_ELSE : 'OP_ELSE',
+    OP_ENDIF : 'OP_ENDIF',
+    OP_VERIFY : 'OP_VERIFY',
+    OP_RETURN : 'OP_RETURN',
+    OP_TOALTSTACK : 'OP_TOALTSTACK',
+    OP_FROMALTSTACK : 'OP_FROMALTSTACK',
+    OP_2DROP : 'OP_2DROP',
+    OP_2DUP : 'OP_2DUP',
+    OP_3DUP : 'OP_3DUP',
+    OP_2OVER : 'OP_2OVER',
+    OP_2ROT : 'OP_2ROT',
+    OP_2SWAP : 'OP_2SWAP',
+    OP_IFDUP : 'OP_IFDUP',
+    OP_DEPTH : 'OP_DEPTH',
+    OP_DROP : 'OP_DROP',
+    OP_DUP : 'OP_DUP',
+    OP_NIP : 'OP_NIP',
+    OP_OVER : 'OP_OVER',
+    OP_PICK : 'OP_PICK',
+    OP_ROLL : 'OP_ROLL',
+    OP_ROT : 'OP_ROT',
+    OP_SWAP : 'OP_SWAP',
+    OP_TUCK : 'OP_TUCK',
+    OP_CAT : 'OP_CAT',
+    OP_SUBSTR : 'OP_SUBSTR',
+    OP_LEFT : 'OP_LEFT',
+    OP_RIGHT : 'OP_RIGHT',
+    OP_SIZE : 'OP_SIZE',
+    OP_INVERT : 'OP_INVERT',
+    OP_AND : 'OP_AND',
+    OP_OR : 'OP_OR',
+    OP_XOR : 'OP_XOR',
+    OP_EQUAL : 'OP_EQUAL',
+    OP_EQUALVERIFY : 'OP_EQUALVERIFY',
+    OP_RESERVED1 : 'OP_RESERVED1',
+    OP_RESERVED2 : 'OP_RESERVED2',
+    OP_1ADD : 'OP_1ADD',
+    OP_1SUB : 'OP_1SUB',
+    OP_2MUL : 'OP_2MUL',
+    OP_2DIV : 'OP_2DIV',
+    OP_NEGATE : 'OP_NEGATE',
+    OP_ABS : 'OP_ABS',
+    OP_NOT : 'OP_NOT',
+    OP_0NOTEQUAL : 'OP_0NOTEQUAL',
+    OP_ADD : 'OP_ADD',
+    OP_SUB : 'OP_SUB',
+    OP_MUL : 'OP_MUL',
+    OP_DIV : 'OP_DIV',
+    OP_MOD : 'OP_MOD',
+    OP_LSHIFT : 'OP_LSHIFT',
+    OP_RSHIFT : 'OP_RSHIFT',
+    OP_BOOLAND : 'OP_BOOLAND',
+    OP_BOOLOR : 'OP_BOOLOR',
+    OP_NUMEQUAL : 'OP_NUMEQUAL',
+    OP_NUMEQUALVERIFY : 'OP_NUMEQUALVERIFY',
+    OP_NUMNOTEQUAL : 'OP_NUMNOTEQUAL',
+    OP_LESSTHAN : 'OP_LESSTHAN',
+    OP_GREATERTHAN : 'OP_GREATERTHAN',
+    OP_LESSTHANOREQUAL : 'OP_LESSTHANOREQUAL',
+    OP_GREATERTHANOREQUAL : 'OP_GREATERTHANOREQUAL',
+    OP_MIN : 'OP_MIN',
+    OP_MAX : 'OP_MAX',
+    OP_WITHIN : 'OP_WITHIN',
+    OP_RIPEMD160 : 'OP_RIPEMD160',
+    OP_SHA1 : 'OP_SHA1',
+    OP_SHA256 : 'OP_SHA256',
+    OP_HASH160 : 'OP_HASH160',
+    OP_HASH256 : 'OP_HASH256',
+    OP_CODESEPARATOR : 'OP_CODESEPARATOR',
+    OP_CHECKSIG : 'OP_CHECKSIG',
+    OP_CHECKSIGVERIFY : 'OP_CHECKSIGVERIFY',
+    OP_CHECKMULTISIG : 'OP_CHECKMULTISIG',
+    OP_CHECKMULTISIGVERIFY : 'OP_CHECKMULTISIGVERIFY',
+    OP_NOP1 : 'OP_NOP1',
+    OP_CHECKLOCKTIMEVERIFY : 'OP_CHECKLOCKTIMEVERIFY',
+    OP_CHECKSEQUENCEVERIFY : 'OP_CHECKSEQUENCEVERIFY',
+    OP_NOP4 : 'OP_NOP4',
+    OP_NOP5 : 'OP_NOP5',
+    OP_NOP6 : 'OP_NOP6',
+    OP_NOP7 : 'OP_NOP7',
+    OP_NOP8 : 'OP_NOP8',
+    OP_NOP9 : 'OP_NOP9',
+    OP_NOP10 : 'OP_NOP10',
+    OP_SMALLINTEGER : 'OP_SMALLINTEGER',
+    OP_PUBKEYS : 'OP_PUBKEYS',
+    OP_PUBKEYHASH : 'OP_PUBKEYHASH',
+    OP_PUBKEY : 'OP_PUBKEY',
+    OP_INVALIDOPCODE : 'OP_INVALIDOPCODE',
+})
+
+OPCODES_BY_NAME = {
+    'OP_0' : OP_0,
+    'OP_PUSHDATA1' : OP_PUSHDATA1,
+    'OP_PUSHDATA2' : OP_PUSHDATA2,
+    'OP_PUSHDATA4' : OP_PUSHDATA4,
+    'OP_1NEGATE' : OP_1NEGATE,
+    'OP_RESERVED' : OP_RESERVED,
+    'OP_1' : OP_1,
+    'OP_2' : OP_2,
+    'OP_3' : OP_3,
+    'OP_4' : OP_4,
+    'OP_5' : OP_5,
+    'OP_6' : OP_6,
+    'OP_7' : OP_7,
+    'OP_8' : OP_8,
+    'OP_9' : OP_9,
+    'OP_10' : OP_10,
+    'OP_11' : OP_11,
+    'OP_12' : OP_12,
+    'OP_13' : OP_13,
+    'OP_14' : OP_14,
+    'OP_15' : OP_15,
+    'OP_16' : OP_16,
+    'OP_NOP' : OP_NOP,
+    'OP_VER' : OP_VER,
+    'OP_IF' : OP_IF,
+    'OP_NOTIF' : OP_NOTIF,
+    'OP_VERIF' : OP_VERIF,
+    'OP_VERNOTIF' : OP_VERNOTIF,
+    'OP_ELSE' : OP_ELSE,
+    'OP_ENDIF' : OP_ENDIF,
+    'OP_VERIFY' : OP_VERIFY,
+    'OP_RETURN' : OP_RETURN,
+    'OP_TOALTSTACK' : OP_TOALTSTACK,
+    'OP_FROMALTSTACK' : OP_FROMALTSTACK,
+    'OP_2DROP' : OP_2DROP,
+    'OP_2DUP' : OP_2DUP,
+    'OP_3DUP' : OP_3DUP,
+    'OP_2OVER' : OP_2OVER,
+    'OP_2ROT' : OP_2ROT,
+    'OP_2SWAP' : OP_2SWAP,
+    'OP_IFDUP' : OP_IFDUP,
+    'OP_DEPTH' : OP_DEPTH,
+    'OP_DROP' : OP_DROP,
+    'OP_DUP' : OP_DUP,
+    'OP_NIP' : OP_NIP,
+    'OP_OVER' : OP_OVER,
+    'OP_PICK' : OP_PICK,
+    'OP_ROLL' : OP_ROLL,
+    'OP_ROT' : OP_ROT,
+    'OP_SWAP' : OP_SWAP,
+    'OP_TUCK' : OP_TUCK,
+    'OP_CAT' : OP_CAT,
+    'OP_SUBSTR' : OP_SUBSTR,
+    'OP_LEFT' : OP_LEFT,
+    'OP_RIGHT' : OP_RIGHT,
+    'OP_SIZE' : OP_SIZE,
+    'OP_INVERT' : OP_INVERT,
+    'OP_AND' : OP_AND,
+    'OP_OR' : OP_OR,
+    'OP_XOR' : OP_XOR,
+    'OP_EQUAL' : OP_EQUAL,
+    'OP_EQUALVERIFY' : OP_EQUALVERIFY,
+    'OP_RESERVED1' : OP_RESERVED1,
+    'OP_RESERVED2' : OP_RESERVED2,
+    'OP_1ADD' : OP_1ADD,
+    'OP_1SUB' : OP_1SUB,
+    'OP_2MUL' : OP_2MUL,
+    'OP_2DIV' : OP_2DIV,
+    'OP_NEGATE' : OP_NEGATE,
+    'OP_ABS' : OP_ABS,
+    'OP_NOT' : OP_NOT,
+    'OP_0NOTEQUAL' : OP_0NOTEQUAL,
+    'OP_ADD' : OP_ADD,
+    'OP_SUB' : OP_SUB,
+    'OP_MUL' : OP_MUL,
+    'OP_DIV' : OP_DIV,
+    'OP_MOD' : OP_MOD,
+    'OP_LSHIFT' : OP_LSHIFT,
+    'OP_RSHIFT' : OP_RSHIFT,
+    'OP_BOOLAND' : OP_BOOLAND,
+    'OP_BOOLOR' : OP_BOOLOR,
+    'OP_NUMEQUAL' : OP_NUMEQUAL,
+    'OP_NUMEQUALVERIFY' : OP_NUMEQUALVERIFY,
+    'OP_NUMNOTEQUAL' : OP_NUMNOTEQUAL,
+    'OP_LESSTHAN' : OP_LESSTHAN,
+    'OP_GREATERTHAN' : OP_GREATERTHAN,
+    'OP_LESSTHANOREQUAL' : OP_LESSTHANOREQUAL,
+    'OP_GREATERTHANOREQUAL' : OP_GREATERTHANOREQUAL,
+    'OP_MIN' : OP_MIN,
+    'OP_MAX' : OP_MAX,
+    'OP_WITHIN' : OP_WITHIN,
+    'OP_RIPEMD160' : OP_RIPEMD160,
+    'OP_SHA1' : OP_SHA1,
+    'OP_SHA256' : OP_SHA256,
+    'OP_HASH160' : OP_HASH160,
+    'OP_HASH256' : OP_HASH256,
+    'OP_CODESEPARATOR' : OP_CODESEPARATOR,
+    'OP_CHECKSIG' : OP_CHECKSIG,
+    'OP_CHECKSIGVERIFY' : OP_CHECKSIGVERIFY,
+    'OP_CHECKMULTISIG' : OP_CHECKMULTISIG,
+    'OP_CHECKMULTISIGVERIFY' : OP_CHECKMULTISIGVERIFY,
+    'OP_NOP1' : OP_NOP1,
+    'OP_CHECKLOCKTIMEVERIFY' : OP_CHECKLOCKTIMEVERIFY,
+    'OP_CHECKSEQUENCEVERIFY' : OP_CHECKSEQUENCEVERIFY,
+    'OP_NOP4' : OP_NOP4,
+    'OP_NOP5' : OP_NOP5,
+    'OP_NOP6' : OP_NOP6,
+    'OP_NOP7' : OP_NOP7,
+    'OP_NOP8' : OP_NOP8,
+    'OP_NOP9' : OP_NOP9,
+    'OP_NOP10' : OP_NOP10,
+    'OP_SMALLINTEGER' : OP_SMALLINTEGER,
+    'OP_PUBKEYS' : OP_PUBKEYS,
+    'OP_PUBKEYHASH' : OP_PUBKEYHASH,
+    'OP_PUBKEY' : OP_PUBKEY,
+}
+
+class CScriptInvalidError(Exception):
+    """Base class for CScript exceptions"""
+    pass
+
+class CScriptTruncatedPushDataError(CScriptInvalidError):
+    """Invalid pushdata due to truncation"""
+    def __init__(self, msg, data):
+        self.data = data
+        super(CScriptTruncatedPushDataError, self).__init__(msg)
+
+# This is used, eg, for blockchain heights in coinbase scripts (bip34)
+class CScriptNum(object):
+    def __init__(self, d=0):
+        self.value = d
+
+    @staticmethod
+    def encode(obj):
+        r = bytearray(0)
+        if obj.value == 0:
+            return bytes(r)
+        neg = obj.value < 0
+        absvalue = -obj.value if neg else obj.value
+        while (absvalue):
+            r.append(absvalue & 0xff)
+            absvalue >>= 8
+        if r[-1] & 0x80:
+            r.append(0x80 if neg else 0)
+        elif neg:
+            r[-1] |= 0x80
+        return bytes(bchr(len(r)) + r)
+
+
+class CScript(bytes):
+    """Serialized script
+
+    A bytes subclass, so you can use this directly whenever bytes are accepted.
+    Note that this means that indexing does *not* work - you'll get an index by
+    byte rather than opcode. This format was chosen for efficiency so that the
+    general case would not require creating a lot of little CScriptOP objects.
+
+    iter(script) however does iterate by opcode.
+    """
+    @classmethod
+    def __coerce_instance(cls, other):
+        # Coerce other into bytes
+        if isinstance(other, CScriptOp):
+            other = bchr(other)
+        elif isinstance(other, CScriptNum):
+            if (other.value == 0):
+                other = bchr(CScriptOp(OP_0))
+            else:
+                other = CScriptNum.encode(other)
+        elif isinstance(other, int):
+            if 0 <= other <= 16:
+                other = bytes(bchr(CScriptOp.encode_op_n(other)))
+            elif other == -1:
+                other = bytes(bchr(OP_1NEGATE))
+            else:
+                other = CScriptOp.encode_op_pushdata(bn2vch(other))
+        elif isinstance(other, (bytes, bytearray)):
+            other = CScriptOp.encode_op_pushdata(other)
+        return other
+
+    def __add__(self, other):
+        # Do the coercion outside of the try block so that errors in it are
+        # noticed.
+        other = self.__coerce_instance(other)
+
+        try:
+            # bytes.__add__ always returns bytes instances unfortunately
+            return CScript(super(CScript, self).__add__(other))
+        except TypeError:
+            raise TypeError('Can not add a %r instance to a CScript' % other.__class__)
+
+    def join(self, iterable):
+        # join makes no sense for a CScript()
+        raise NotImplementedError
+
+    def __new__(cls, value=b''):
+        if isinstance(value, bytes) or isinstance(value, bytearray):
+            return super(CScript, cls).__new__(cls, value)
+        else:
+            def coerce_iterable(iterable):
+                for instance in iterable:
+                    yield cls.__coerce_instance(instance)
+            # Annoyingly on both python2 and python3 bytes.join() always
+            # returns a bytes instance even when subclassed.
+            return super(CScript, cls).__new__(cls, b''.join(coerce_iterable(value)))
+
+    def raw_iter(self):
+        """Raw iteration
+
+        Yields tuples of (opcode, data, sop_idx) so that the different possible
+        PUSHDATA encodings can be accurately distinguished, as well as
+        determining the exact opcode byte indexes. (sop_idx)
+        """
+        i = 0
+        while i < len(self):
+            sop_idx = i
+            opcode = bord(self[i])
+            i += 1
+
+            if opcode > OP_PUSHDATA4:
+                yield (opcode, None, sop_idx)
+            else:
+                datasize = None
+                pushdata_type = None
+                if opcode < OP_PUSHDATA1:
+                    pushdata_type = 'PUSHDATA(%d)' % opcode
+                    datasize = opcode
+
+                elif opcode == OP_PUSHDATA1:
+                    pushdata_type = 'PUSHDATA1'
+                    if i >= len(self):
+                        raise CScriptInvalidError('PUSHDATA1: missing data length')
+                    datasize = bord(self[i])
+                    i += 1
+
+                elif opcode == OP_PUSHDATA2:
+                    pushdata_type = 'PUSHDATA2'
+                    if i + 1 >= len(self):
+                        raise CScriptInvalidError('PUSHDATA2: missing data length')
+                    datasize = bord(self[i]) + (bord(self[i+1]) << 8)
+                    i += 2
+
+                elif opcode == OP_PUSHDATA4:
+                    pushdata_type = 'PUSHDATA4'
+                    if i + 3 >= len(self):
+                        raise CScriptInvalidError('PUSHDATA4: missing data length')
+                    datasize = bord(self[i]) + (bord(self[i+1]) << 8) + (bord(self[i+2]) << 16) + (bord(self[i+3]) << 24)
+                    i += 4
+
+                else:
+                    assert False # shouldn't happen
+
+
+                data = bytes(self[i:i+datasize])
+
+                # Check for truncation
+                if len(data) < datasize:
+                    raise CScriptTruncatedPushDataError('%s: truncated data' % pushdata_type, data)
+
+                i += datasize
+
+                yield (opcode, data, sop_idx)
+
+    def __iter__(self):
+        """'Cooked' iteration
+
+        Returns either a CScriptOP instance, an integer, or bytes, as
+        appropriate.
+
+        See raw_iter() if you need to distinguish the different possible
+        PUSHDATA encodings.
+        """
+        for (opcode, data, sop_idx) in self.raw_iter():
+            if data is not None:
+                yield data
+            else:
+                opcode = CScriptOp(opcode)
+
+                if opcode.is_small_int():
+                    yield opcode.decode_op_n()
+                else:
+                    yield CScriptOp(opcode)
+
+    def __repr__(self):
+        # For Python3 compatibility add b before strings so testcases don't
+        # need to change
+        def _repr(o):
+            if isinstance(o, bytes):
+                return b"x('%s')" % hexlify(o).decode('ascii')
+            else:
+                return repr(o)
+
+        ops = []
+        i = iter(self)
+        while True:
+            op = None
+            try:
+                op = _repr(next(i))
+            except CScriptTruncatedPushDataError as err:
+                op = '%s...<ERROR: %s>' % (_repr(err.data), err)
+                break
+            except CScriptInvalidError as err:
+                op = '<ERROR: %s>' % err
+                break
+            except StopIteration:
+                break
+            finally:
+                if op is not None:
+                    ops.append(op)
+
+        return "CScript([%s])" % ', '.join(ops)
+
+    def GetSigOpCount(self, fAccurate):
+        """Get the SigOp count.
+
+        fAccurate - Accurately count CHECKMULTISIG, see BIP16 for details.
+
+        Note that this is consensus-critical.
+        """
+        n = 0
+        lastOpcode = OP_INVALIDOPCODE
+        for (opcode, data, sop_idx) in self.raw_iter():
+            if opcode in (OP_CHECKSIG, OP_CHECKSIGVERIFY):
+                n += 1
+            elif opcode in (OP_CHECKMULTISIG, OP_CHECKMULTISIGVERIFY):
+                if fAccurate and (OP_1 <= lastOpcode <= OP_16):
+                    n += opcode.decode_op_n()
+                else:
+                    n += 20
+            lastOpcode = opcode
+        return n
+
+
+SIGHASH_ALL = 1
+SIGHASH_NONE = 2
+SIGHASH_SINGLE = 3
+SIGHASH_ANYONECANPAY = 0x80
+
+def FindAndDelete(script, sig):
+    """Consensus critical, see FindAndDelete() in Satoshi codebase"""
+    r = b''
+    last_sop_idx = sop_idx = 0
+    skip = True
+    for (opcode, data, sop_idx) in script.raw_iter():
+        if not skip:
+            r += script[last_sop_idx:sop_idx]
+        last_sop_idx = sop_idx
+        if script[sop_idx:sop_idx + len(sig)] == sig:
+            skip = True
+        else:
+            skip = False
+    if not skip:
+        r += script[last_sop_idx:]
+    return CScript(r)
+
+
+def SignatureHash(script, txTo, inIdx, hashtype):
+    """Consensus-correct SignatureHash
+
+    Returns (hash, err) to precisely match the consensus-critical behavior of
+    the SIGHASH_SINGLE bug. (inIdx is *not* checked for validity)
+    """
+    HASH_ONE = b'\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+
+    if inIdx >= len(txTo.vin):
+        return (HASH_ONE, "inIdx %d out of range (%d)" % (inIdx, len(txTo.vin)))
+    txtmp = CTransaction(txTo)
+
+    for txin in txtmp.vin:
+        txin.scriptSig = b''
+    txtmp.vin[inIdx].scriptSig = FindAndDelete(script, CScript([OP_CODESEPARATOR]))
+
+    if (hashtype & 0x1f) == SIGHASH_NONE:
+        txtmp.vout = []
+
+        for i in range(len(txtmp.vin)):
+            if i != inIdx:
+                txtmp.vin[i].nSequence = 0
+
+    elif (hashtype & 0x1f) == SIGHASH_SINGLE:
+        outIdx = inIdx
+        if outIdx >= len(txtmp.vout):
+            return (HASH_ONE, "outIdx %d out of range (%d)" % (outIdx, len(txtmp.vout)))
+
+        tmp = txtmp.vout[outIdx]
+        txtmp.vout = []
+        for i in range(outIdx):
+            txtmp.vout.append(CTxOut())
+        txtmp.vout.append(tmp)
+
+        for i in range(len(txtmp.vin)):
+            if i != inIdx:
+                txtmp.vin[i].nSequence = 0
+
+    if hashtype & SIGHASH_ANYONECANPAY:
+        tmp = txtmp.vin[inIdx]
+        txtmp.vin = []
+        txtmp.vin.append(tmp)
+
+    s = txtmp.serialize()
+    s += struct.pack(b"<I", hashtype)
+
+    hash = hash256(s)
+
+    return (hash, None)
+
+# TODO: Allow cached hashPrevouts/hashSequence/hashOutputs to be provided.
+# Performance optimization probably not necessary for python tests, however.
+# Note that this corresponds to sigversion == 1 in EvalScript, which is used
+# for version 0 witnesses.
+def SegwitVersion1SignatureHash(script, txTo, inIdx, hashtype, amount):
+
+    hashPrevouts = 0
+    hashSequence = 0
+    hashOutputs = 0
+
+    if not (hashtype & SIGHASH_ANYONECANPAY):
+        serialize_prevouts = bytes()
+        for i in txTo.vin:
+            serialize_prevouts += i.prevout.serialize()
+        hashPrevouts = uint256_from_str(hash256(serialize_prevouts))
+
+    if (not (hashtype & SIGHASH_ANYONECANPAY) and (hashtype & 0x1f) != SIGHASH_SINGLE and (hashtype & 0x1f) != SIGHASH_NONE):
+        serialize_sequence = bytes()
+        for i in txTo.vin:
+            serialize_sequence += struct.pack("<I", i.nSequence)
+        hashSequence = uint256_from_str(hash256(serialize_sequence))
+
+    if ((hashtype & 0x1f) != SIGHASH_SINGLE and (hashtype & 0x1f) != SIGHASH_NONE):
+        serialize_outputs = bytes()
+        for o in txTo.vout:
+            serialize_outputs += o.serialize()
+        hashOutputs = uint256_from_str(hash256(serialize_outputs))
+    elif ((hashtype & 0x1f) == SIGHASH_SINGLE and inIdx < len(txTo.vout)):
+        serialize_outputs = txTo.vout[inIdx].serialize()
+        hashOutputs = uint256_from_str(hash256(serialize_outputs))
+
+    ss = bytes()
+    ss += struct.pack("<i", txTo.nVersion)
+    ss += ser_uint256(hashPrevouts)
+    ss += ser_uint256(hashSequence)
+    ss += txTo.vin[inIdx].prevout.serialize()
+    ss += ser_string(script)
+    ss += struct.pack("<q", amount)
+    ss += struct.pack("<I", txTo.vin[inIdx].nSequence)
+    ss += ser_uint256(hashOutputs)
+    ss += struct.pack("<i", txTo.nLockTime)
+    ss += struct.pack("<I", hashtype)
+
+    return hash256(ss)

basicswap/interface/contrib/nav_test_framework/siphash.py

@@ -0,0 +1,63 @@
+#!/usr/bin/env python3
+# Copyright (c) 2016-2018 The Bitcoin Core developers
+# Distributed under the MIT software license, see the accompanying
+# file COPYING or http://www.opensource.org/licenses/mit-license.php.
+"""Specialized SipHash-2-4 implementations.
+
+This implements SipHash-2-4 for 256-bit integers.
+"""
+
+def rotl64(n, b):
+    return n >> (64 - b) | (n & ((1 << (64 - b)) - 1)) << b
+
+def siphash_round(v0, v1, v2, v3):
+    v0 = (v0 + v1) & ((1 << 64) - 1)
+    v1 = rotl64(v1, 13)
+    v1 ^= v0
+    v0 = rotl64(v0, 32)
+    v2 = (v2 + v3) & ((1 << 64) - 1)
+    v3 = rotl64(v3, 16)
+    v3 ^= v2
+    v0 = (v0 + v3) & ((1 << 64) - 1)
+    v3 = rotl64(v3, 21)
+    v3 ^= v0
+    v2 = (v2 + v1) & ((1 << 64) - 1)
+    v1 = rotl64(v1, 17)
+    v1 ^= v2
+    v2 = rotl64(v2, 32)
+    return (v0, v1, v2, v3)
+
+def siphash256(k0, k1, h):
+    n0 = h & ((1 << 64) - 1)
+    n1 = (h >> 64) & ((1 << 64) - 1)
+    n2 = (h >> 128) & ((1 << 64) - 1)
+    n3 = (h >> 192) & ((1 << 64) - 1)
+    v0 = 0x736f6d6570736575 ^ k0
+    v1 = 0x646f72616e646f6d ^ k1
+    v2 = 0x6c7967656e657261 ^ k0
+    v3 = 0x7465646279746573 ^ k1 ^ n0
+    v0, v1, v2, v3 = siphash_round(v0, v1, v2, v3)
+    v0, v1, v2, v3 = siphash_round(v0, v1, v2, v3)
+    v0 ^= n0
+    v3 ^= n1
+    v0, v1, v2, v3 = siphash_round(v0, v1, v2, v3)
+    v0, v1, v2, v3 = siphash_round(v0, v1, v2, v3)
+    v0 ^= n1
+    v3 ^= n2
+    v0, v1, v2, v3 = siphash_round(v0, v1, v2, v3)
+    v0, v1, v2, v3 = siphash_round(v0, v1, v2, v3)
+    v0 ^= n2
+    v3 ^= n3
+    v0, v1, v2, v3 = siphash_round(v0, v1, v2, v3)
+    v0, v1, v2, v3 = siphash_round(v0, v1, v2, v3)
+    v0 ^= n3
+    v3 ^= 0x2000000000000000
+    v0, v1, v2, v3 = siphash_round(v0, v1, v2, v3)
+    v0, v1, v2, v3 = siphash_round(v0, v1, v2, v3)
+    v0 ^= 0x2000000000000000
+    v2 ^= 0xFF
+    v0, v1, v2, v3 = siphash_round(v0, v1, v2, v3)
+    v0, v1, v2, v3 = siphash_round(v0, v1, v2, v3)
+    v0, v1, v2, v3 = siphash_round(v0, v1, v2, v3)
+    v0, v1, v2, v3 = siphash_round(v0, v1, v2, v3)
+    return v0 ^ v1 ^ v2 ^ v3

basicswap/interface/contrib/nav_test_framework/util.py

@@ -0,0 +1,700 @@
+#!/usr/bin/env python3
+# Copyright (c) 2014-2016 The Bitcoin Core developers
+# Distributed under the MIT software license, see the accompanying
+# file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+
+#
+# Helpful routines for regression testing
+#
+
+import os
+import sys
+
+from binascii import hexlify, unhexlify
+from base64 import b64encode
+from decimal import Decimal, ROUND_DOWN
+import json
+import http.client
+import random
+import shutil
+import subprocess
+import time
+import re
+import errno
+
+from . import coverage
+from .authproxy import AuthServiceProxy, JSONRPCException
+
+COVERAGE_DIR = None
+
+# The maximum number of nodes a single test can spawn
+MAX_NODES = 8
+# Don't assign rpc or p2p ports lower than this
+PORT_MIN = 11000
+# The number of ports to "reserve" for p2p and rpc, each
+PORT_RANGE = 5000
+
+NAVCOIND_PROC_WAIT_TIMEOUT = 60
+
+
+class PortSeed:
+    # Must be initialized with a unique integer for each process
+    n = None
+
+#Set Mocktime default to OFF.
+#MOCKTIME is only needed for scripts that use the
+#cached version of the blockchain.  If the cached
+#version of the blockchain is used without MOCKTIME
+#then the mempools will not sync due to IBD.
+MOCKTIME = 0
+
+def enable_mocktime():
+    #For backwared compatibility of the python scripts
+    #with previous versions of the cache, set MOCKTIME
+    #to Jan 1, 2014 + (201 * 10 * 60)
+    global MOCKTIME
+    MOCKTIME = 1388534400 + (201 * 10 * 60)
+
+def disable_mocktime():
+    global MOCKTIME
+    MOCKTIME = 0
+
+def get_mocktime():
+    return MOCKTIME
+
+def enable_coverage(dirname):
+    """Maintain a log of which RPC calls are made during testing."""
+    global COVERAGE_DIR
+    COVERAGE_DIR = dirname
+
+def get_rpc_proxy(url, node_number, timeout=None):
+    """
+    Args:
+        url (str): URL of the RPC server to call
+        node_number (int): the node number (or id) that this calls to
+
+    Kwargs:
+        timeout (int): HTTP timeout in seconds
+
+    Returns:
+        AuthServiceProxy. convenience object for making RPC calls.
+
+    """
+    proxy_kwargs = {}
+    if timeout is not None:
+        proxy_kwargs['timeout'] = timeout
+
+    proxy = AuthServiceProxy(url, **proxy_kwargs)
+    proxy.url = url  # store URL on proxy for info
+
+    coverage_logfile = coverage.get_filename(
+        COVERAGE_DIR, node_number) if COVERAGE_DIR else None
+
+    return coverage.AuthServiceProxyWrapper(proxy, coverage_logfile)
+
+
+def p2p_port(n):
+    assert(n <= MAX_NODES)
+    return PORT_MIN + n + (MAX_NODES * PortSeed.n) % (PORT_RANGE - 1 - MAX_NODES)
+
+def rpc_port(n):
+    return PORT_MIN + PORT_RANGE + n + (MAX_NODES * PortSeed.n) % (PORT_RANGE - 1 - MAX_NODES)
+
+def check_json_precision():
+    """Make sure json library being used does not lose precision converting NAV values"""
+    n = Decimal("20000000.00000003")
+    satoshis = int(json.loads(json.dumps(float(n)))*1.0e8)
+    if satoshis != 2000000000000003:
+        raise RuntimeError("JSON encode/decode loses precision")
+
+def count_bytes(hex_string):
+    return len(bytearray.fromhex(hex_string))
+
+def bytes_to_hex_str(byte_str):
+    return hexlify(byte_str).decode('ascii')
+
+def hex_str_to_bytes(hex_str):
+    return unhexlify(hex_str.encode('ascii'))
+
+def str_to_b64str(string):
+    return b64encode(string.encode('utf-8')).decode('ascii')
+
+def sync_blocks(rpc_connections, wait=1, timeout=60):
+    """
+    Wait until everybody has the same tip
+    """
+    while timeout > 0:
+        tips = [ x.getbestblockhash() for x in rpc_connections ]
+        if tips == [ tips[0] ]*len(tips):
+        #if all x.getblockhash() in tips are the same return True
+            return True
+        time.sleep(wait)
+        timeout -= wait
+    raise AssertionError("Block sync failed")
+
+def sync_mempools(rpc_connections, wait=1, timeout=60):
+    """
+    Wait until everybody has the same transactions in their memory
+    pools
+    """
+    while timeout > 0:
+        pool = set(rpc_connections[0].getrawmempool())
+        num_match = 1
+        for i in range(1, len(rpc_connections)):
+            if set(rpc_connections[i].getrawmempool()) == pool:
+                num_match = num_match+1
+        if num_match == len(rpc_connections):
+            return True
+        time.sleep(wait)
+        timeout -= wait
+    raise AssertionError("Mempool sync failed")
+
+navcoind_processes = {}
+
+def initialize_datadir(dirname, n):
+    datadir = os.path.join(dirname, "node"+str(n))
+    if not os.path.isdir(datadir):
+        os.makedirs(datadir)
+    rpc_u, rpc_p = rpc_auth_pair(n)
+    with open(os.path.join(datadir, "navcoin.conf"), 'w') as f:
+        f.write("devnet=1\n")
+        f.write("rpcuser=" + rpc_u + "\n")
+        f.write("rpcpassword=" + rpc_p + "\n")
+        f.write("port="+str(p2p_port(n))+"\n")
+        f.write("rpcport="+str(rpc_port(n))+"\n")
+        f.write("listenonion=0\n")
+        f.write("dandelion=0\n")
+        f.write("ntpminmeasures=-1\n")
+        f.write("torserver=0\n")
+        f.write("suppressblsctwarning=1\n")
+    return datadir
+
+def rpc_auth_pair(n):
+    return 'rpcuser💻' + str(n), 'rpcpass🔑' + str(n)
+
+def rpc_url(i, rpchost=None):
+    rpc_u, rpc_p = rpc_auth_pair(i)
+    return "http://%s:%s@%s:%d" % (rpc_u, rpc_p, rpchost or '127.0.0.1', rpc_port(i))
+
+def wait_for_navcoind_start(process, url, i):
+    '''
+    Wait for navcoind to start. This means that RPC is accessible and fully initialized.
+    Raise an exception if navcoind exits during initialization.
+    '''
+    polls_interval = 1.0 / 4
+    runtime = 60
+    while runtime > 0:
+        if process.poll() is not None:
+            raise Exception('navcoind exited with status %i during initialization' % process.returncode)
+        try:
+            # print('Checking RPC')
+            rpc = get_rpc_proxy(url, i)
+            blocks = rpc.getblockcount()
+            # print('RPC replied with blocks: %i' % blocks)
+            return # break out of loop on success
+        except IOError as e:
+            if e.errno != errno.ECONNREFUSED: # Port not yet open?
+                raise # unknown IO error
+            # else:
+            #     print('Waiting for port')
+        except JSONRPCException as e: # Initialization phase
+            if e.error['code'] != -28: # RPC in warmup?
+                raise # unkown JSON RPC exception
+            # else:
+            #     print('RPC in warmup')
+        time.sleep(polls_interval)
+        runtime -= polls_interval
+    raise Exception('navcoind RPC timeout')
+
+def initialize_chain(test_dir, num_nodes):
+    """
+    Create a cache of a 200-block-long chain (with wallet) for MAX_NODES
+    Afterward, create num_nodes copies from the cache
+    """
+
+    assert num_nodes <= MAX_NODES
+    create_cache = False
+    for i in range(MAX_NODES):
+        if not os.path.isdir(os.path.join('cache', 'node'+str(i))):
+            create_cache = True
+            break
+
+    if create_cache:
+
+        #find and delete old cache directories if any exist
+        for i in range(MAX_NODES):
+            if os.path.isdir(os.path.join("cache","node"+str(i))):
+                shutil.rmtree(os.path.join("cache","node"+str(i)))
+
+        # Create cache directories, run navcoinds:
+        for i in range(MAX_NODES):
+            datadir=initialize_datadir("cache", i)
+            args = [ os.getenv("NAVCOIND", "navcoind"), "-server", "-keypool=1", "-datadir="+datadir, "-discover=0" ]
+            if i > 0:
+                args.append("-connect=127.0.0.1:"+str(p2p_port(0)))
+            navcoind_processes[i] = subprocess.Popen(args)
+            if os.getenv("PYTHON_DEBUG", ""):
+                print("initialize_chain: navcoind started, waiting for RPC to come up")
+            wait_for_navcoind_start(navcoind_processes[i], rpc_url(i), i)
+            if os.getenv("PYTHON_DEBUG", ""):
+                print("initialize_chain: RPC succesfully started")
+
+        rpcs = []
+        for i in range(MAX_NODES):
+            try:
+                rpcs.append(get_rpc_proxy(rpc_url(i), i))
+            except:
+                sys.stderr.write("Error connecting to "+url+"\n")
+                sys.exit(1)
+
+        # Create a 200-block-long chain; each of the 4 first nodes
+        # gets 25 mature blocks and 25 immature.
+        # Note: To preserve compatibility with older versions of
+        # initialize_chain, only 4 nodes will generate coins.
+        #
+        # blocks are created with timestamps 10 minutes apart
+        # starting from 2010 minutes in the past
+        enable_mocktime()
+        block_time = get_mocktime() - (201 * 10 * 60)
+        for i in range(2):
+            for peer in range(4):
+                for j in range(25):
+                    set_node_times(rpcs, block_time)
+                    slow_gen(rpcs[peer], 1)
+                    block_time += 10*60
+                # Must sync before next peer starts generating blocks
+                sync_blocks(rpcs)
+
+        # Shut them down, and clean up cache directories:
+        stop_nodes(rpcs)
+        wait_navcoinds()
+        disable_mocktime()
+        for i in range(MAX_NODES):
+            os.remove(log_filename("cache", i, "debug.log"))
+            os.remove(log_filename("cache", i, "db.log"))
+            os.remove(log_filename("cache", i, "peers.dat"))
+            os.remove(log_filename("cache", i, "fee_estimates.dat"))
+
+    for i in range(num_nodes):
+        from_dir = os.path.join("cache", "node"+str(i))
+        to_dir = os.path.join(test_dir,  "node"+str(i))
+        shutil.copytree(from_dir, to_dir)
+        initialize_datadir(test_dir, i) # Overwrite port/rpcport in navcoin.conf
+
+def initialize_chain_clean(test_dir, num_nodes):
+    """
+    Create an empty blockchain and num_nodes wallets.
+    Useful if a test case wants complete control over initialization.
+    """
+    for i in range(num_nodes):
+        datadir=initialize_datadir(test_dir, i)
+
+
+def _rpchost_to_args(rpchost):
+    '''Convert optional IP:port spec to rpcconnect/rpcport args'''
+    if rpchost is None:
+        return []
+
+    match = re.match('(\[[0-9a-fA-f:]+\]|[^:]+)(?::([0-9]+))?$', rpchost)
+    if not match:
+        raise ValueError('Invalid RPC host spec ' + rpchost)
+
+    rpcconnect = match.group(1)
+    rpcport = match.group(2)
+
+    if rpcconnect.startswith('['): # remove IPv6 [...] wrapping
+        rpcconnect = rpcconnect[1:-1]
+
+    rv = ['-rpcconnect=' + rpcconnect]
+    if rpcport:
+        rv += ['-rpcport=' + rpcport]
+    return rv
+
+def start_node(i, dirname, extra_args=None, rpchost=None, timewait=None, binary=None):
+    """
+    Start a navcoind and return RPC connection to it
+    """
+    datadir = os.path.join(dirname, "node"+str(i))
+    if binary is None:
+        binary = os.getenv("NAVCOIND", "navcoind")
+    args = [ binary, "-datadir="+datadir, "-server", "-keypool=1", "-discover=0", "-rest", "-mocktime="+str(get_mocktime()) ]
+    if extra_args is not None: args.extend(extra_args)
+    navcoind_processes[i] = subprocess.Popen(args)
+    if os.getenv("PYTHON_DEBUG", ""):
+        print("start_node: navcoind started, waiting for RPC to come up")
+    url = rpc_url(i, rpchost)
+    wait_for_navcoind_start(navcoind_processes[i], url, i)
+    if os.getenv("PYTHON_DEBUG", ""):
+        print("start_node: RPC succesfully started")
+    proxy = get_rpc_proxy(url, i, timeout=timewait)
+
+    if COVERAGE_DIR:
+        coverage.write_all_rpc_commands(COVERAGE_DIR, proxy)
+
+    return proxy
+
+def start_nodes(num_nodes, dirname, extra_args=None, rpchost=None, binary=None):
+    """
+    Start multiple navcoinds, return RPC connections to them
+    """
+    if extra_args is None: extra_args = [ None for _ in range(num_nodes) ]
+    if binary is None: binary = [ None for _ in range(num_nodes) ]
+    rpcs = []
+    try:
+        for i in range(num_nodes):
+            rpcs.append(start_node(i, dirname, extra_args[i], rpchost, binary=binary[i]))
+    except: # If one node failed to start, stop the others
+        stop_nodes(rpcs)
+        raise
+    return rpcs
+
+def log_filename(dirname, n_node, logname):
+    return os.path.join(dirname, "node"+str(n_node), "devnet", logname)
+
+def stop_node(node, i):
+    try:
+        node.stop()
+    except http.client.CannotSendRequest as e:
+        print("WARN: Unable to stop node: " + repr(e))
+    navcoind_processes[i].wait(timeout=NAVCOIND_PROC_WAIT_TIMEOUT)
+    del navcoind_processes[i]
+
+def stop_nodes(nodes):
+    for node in nodes:
+        try:
+            node.stop()
+        except http.client.CannotSendRequest as e:
+            print("WARN: Unable to stop node: " + repr(e))
+    del nodes[:] # Emptying array closes connections as a side effect
+
+def set_node_times(nodes, t):
+    for node in nodes:
+        node.setmocktime(t)
+
+def wait_navcoinds():
+    # Wait for all navcoinds to cleanly exit
+    for navcoind in navcoind_processes.values():
+        navcoind.wait(timeout=NAVCOIND_PROC_WAIT_TIMEOUT)
+    navcoind_processes.clear()
+
+def connect_nodes(from_connection, node_num):
+    ip_port = "127.0.0.1:"+str(p2p_port(node_num))
+    from_connection.addnode(ip_port, "onetry")
+    # poll until version handshake complete to avoid race conditions
+    # with transaction relaying
+    while any(peer['version'] == 0 for peer in from_connection.getpeerinfo()):
+        time.sleep(0.1)
+
+def connect_nodes_bi(nodes, a, b):
+    connect_nodes(nodes[a], b)
+    connect_nodes(nodes[b], a)
+
+def find_output(node, txid, amount):
+    """
+    Return index to output of txid with value amount
+    Raises exception if there is none.
+    """
+    txdata = node.getrawtransaction(txid, 1)
+    for i in range(len(txdata["vout"])):
+        if txdata["vout"][i]["value"] == amount:
+            return i
+    raise RuntimeError("find_output txid %s : %s not found"%(txid,str(amount)))
+
+
+def gather_inputs(from_node, amount_needed, confirmations_required=1):
+    """
+    Return a random set of unspent txouts that are enough to pay amount_needed
+    """
+    assert(confirmations_required >=0)
+    utxo = from_node.listunspent(confirmations_required)
+    random.shuffle(utxo)
+    inputs = []
+    total_in = Decimal("0.00000000")
+    while total_in < amount_needed and len(utxo) > 0:
+        t = utxo.pop()
+        total_in += t["amount"]
+        inputs.append({ "txid" : t["txid"], "vout" : t["vout"], "address" : t["address"] } )
+    if total_in < amount_needed:
+        raise RuntimeError("Insufficient funds: need %d, have %d"%(amount_needed, total_in))
+    return (total_in, inputs)
+
+def make_change(from_node, amount_in, amount_out, fee):
+    """
+    Create change output(s), return them
+    """
+    outputs = {}
+    amount = amount_out+fee
+    change = amount_in - amount
+    if change > amount*2:
+        # Create an extra change output to break up big inputs
+        change_address = from_node.getnewaddress()
+        # Split change in two, being careful of rounding:
+        outputs[change_address] = Decimal(change/2).quantize(Decimal('0.00000001'), rounding=ROUND_DOWN)
+        change = amount_in - amount - outputs[change_address]
+    if change > 0:
+        outputs[from_node.getnewaddress()] = change
+    return outputs
+
+def send_zeropri_transaction(from_node, to_node, amount, fee):
+    """
+    Create&broadcast a zero-priority transaction.
+    Returns (txid, hex-encoded-txdata)
+    Ensures transaction is zero-priority by first creating a send-to-self,
+    then using its output
+    """
+
+    # Create a send-to-self with confirmed inputs:
+    self_address = from_node.getnewaddress()
+    (total_in, inputs) = gather_inputs(from_node, amount+fee*2)
+    outputs = make_change(from_node, total_in, amount+fee, fee)
+    outputs[self_address] = float(amount+fee)
+
+    self_rawtx = from_node.createrawtransaction(inputs, outputs)
+    self_signresult = from_node.signrawtransaction(self_rawtx)
+    self_txid = from_node.sendrawtransaction(self_signresult["hex"], True)
+
+    vout = find_output(from_node, self_txid, amount+fee)
+    # Now immediately spend the output to create a 1-input, 1-output
+    # zero-priority transaction:
+    inputs = [ { "txid" : self_txid, "vout" : vout } ]
+    outputs = { to_node.getnewaddress() : float(amount) }
+
+    rawtx = from_node.createrawtransaction(inputs, outputs)
+    signresult = from_node.signrawtransaction(rawtx)
+    txid = from_node.sendrawtransaction(signresult["hex"], True)
+
+    return (txid, signresult["hex"])
+
+def random_zeropri_transaction(nodes, amount, min_fee, fee_increment, fee_variants):
+    """
+    Create a random zero-priority transaction.
+    Returns (txid, hex-encoded-transaction-data, fee)
+    """
+    from_node = random.choice(nodes)
+    to_node = random.choice(nodes)
+    fee = min_fee + fee_increment*random.randint(0,fee_variants)
+    (txid, txhex) = send_zeropri_transaction(from_node, to_node, amount, fee)
+    return (txid, txhex, fee)
+
+def random_transaction(nodes, amount, min_fee, fee_increment, fee_variants):
+    """
+    Create a random transaction.
+    Returns (txid, hex-encoded-transaction-data, fee)
+    """
+    from_node = random.choice(nodes)
+    to_node = random.choice(nodes)
+    fee = min_fee + fee_increment*random.randint(0,fee_variants)
+
+    (total_in, inputs) = gather_inputs(from_node, amount+fee)
+    outputs = make_change(from_node, total_in, amount, fee)
+    outputs[to_node.getnewaddress()] = float(amount)
+
+    rawtx = from_node.createrawtransaction(inputs, outputs)
+    signresult = from_node.signrawtransaction(rawtx)
+    txid = from_node.sendrawtransaction(signresult["hex"], True)
+
+    return (txid, signresult["hex"], fee)
+
+def assert_fee_amount(fee, tx_size, fee_per_kB):
+    """Assert the fee was in range"""
+    target_fee = tx_size * fee_per_kB / 1000
+    if fee < target_fee:
+        raise AssertionError("Fee of %s NAV too low! (Should be %s NAV)"%(str(fee), str(target_fee)))
+    # allow the wallet's estimation to be at most 2 bytes off
+    if fee > (tx_size + 2) * fee_per_kB / 1000:
+        raise AssertionError("Fee of %s NAV too high! (Should be %s NAV)"%(str(fee), str(target_fee)))
+
+def assert_equal(thing1, thing2):
+    if thing1 != thing2:
+        raise AssertionError("%s != %s"%(str(thing1),str(thing2)))
+
+def assert_greater_than(thing1, thing2):
+    if thing1 <= thing2:
+        raise AssertionError("%s <= %s"%(str(thing1),str(thing2)))
+
+def assert_raises(exc, fun, *args, **kwds):
+    try:
+        fun(*args, **kwds)
+    except exc:
+        pass
+    except Exception as e:
+        raise AssertionError("Unexpected exception raised: "+type(e).__name__)
+    else:
+        raise AssertionError("No exception raised")
+
+def assert_is_hex_string(string):
+    try:
+        int(string, 16)
+    except Exception as e:
+        raise AssertionError(
+            "Couldn't interpret %r as hexadecimal; raised: %s" % (string, e))
+
+def assert_is_hash_string(string, length=64):
+    if not isinstance(string, str):
+        raise AssertionError("Expected a string, got type %r" % type(string))
+    elif length and len(string) != length:
+        raise AssertionError(
+            "String of length %d expected; got %d" % (length, len(string)))
+    elif not re.match('[abcdef0-9]+$', string):
+        raise AssertionError(
+            "String %r contains invalid characters for a hash." % string)
+
+def assert_array_result(object_array, to_match, expected, should_not_find = False):
+    """
+        Pass in array of JSON objects, a dictionary with key/value pairs
+        to match against, and another dictionary with expected key/value
+        pairs.
+        If the should_not_find flag is true, to_match should not be found
+        in object_array
+        """
+    if should_not_find == True:
+        assert_equal(expected, { })
+    num_matched = 0
+    for item in object_array:
+        all_match = True
+        for key,value in to_match.items():
+            if item[key] != value:
+                all_match = False
+        if not all_match:
+            continue
+        elif should_not_find == True:
+            num_matched = num_matched+1
+        for key,value in expected.items():
+            if item[key] != value:
+                raise AssertionError("%s : expected %s=%s"%(str(item), str(key), str(value)))
+            num_matched = num_matched+1
+    if num_matched == 0 and should_not_find != True:
+        raise AssertionError("No objects matched %s"%(str(to_match)))
+    if num_matched > 0 and should_not_find == True:
+        raise AssertionError("Objects were found %s"%(str(to_match)))
+
+def assert_raises_rpc_error(code, message, fun, *args, **kwds):
+    """Run an RPC and verify that a specific JSONRPC exception code and message is raised.
+    Calls function `fun` with arguments `args` and `kwds`. Catches a JSONRPCException
+    and verifies that the error code and message are as expected. Throws AssertionError if
+    no JSONRPCException was raised or if the error code/message are not as expected.
+    Args:
+        code (int), optional: the error code returned by the RPC call (defined
+            in src/rpc/protocol.h). Set to None if checking the error code is not required.
+        message (string), optional: [a substring of] the error string returned by the
+            RPC call. Set to None if checking the error string is not required.
+        fun (function): the function to call. This should be the name of an RPC.
+        args*: positional arguments for the function.
+        kwds**: named arguments for the function.
+    """
+    assert try_rpc(code, message, fun, *args, **kwds), "No exception raised"
+
+def try_rpc(code, message, fun, *args, **kwds):
+    """Tries to run an rpc command.
+    Test against error code and message if the rpc fails.
+    Returns whether a JSONRPCException was raised."""
+    try:
+        fun(*args, **kwds)
+    except JSONRPCException as e:
+        # JSONRPCException was thrown as expected. Check the code and message values are correct.
+        if (code is not None) and (code != e.error["code"]):
+            raise AssertionError("Unexpected JSONRPC error code %i" % e.error["code"])
+        if (message is not None) and (message not in e.error['message']):
+            raise AssertionError("Expected substring not found:" + e.error['message'])
+        return True
+    except Exception as e:
+        raise AssertionError("Unexpected exception raised: " + type(e).__name__)
+    else:
+        return False
+
+def satoshi_round(amount):
+    return Decimal(amount).quantize(Decimal('0.00000001'), rounding=ROUND_DOWN)
+
+# Helper to create at least "count" utxos
+# Pass in a fee that is sufficient for relay and mining new transactions.
+def create_confirmed_utxos(fee, node, count):
+    node.generate(int(0.5*count)+101)
+    utxos = node.listunspent()
+    iterations = count - len(utxos)
+    addr1 = node.getnewaddress()
+    addr2 = node.getnewaddress()
+    if iterations <= 0:
+        return utxos
+    for i in range(iterations):
+        t = utxos.pop()
+        inputs = []
+        inputs.append({ "txid" : t["txid"], "vout" : t["vout"]})
+        outputs = {}
+        send_value = t['amount'] - fee
+        outputs[addr1] = satoshi_round(send_value/2)
+        outputs[addr2] = satoshi_round(send_value/2)
+        raw_tx = node.createrawtransaction(inputs, outputs)
+        signed_tx = node.signrawtransaction(raw_tx)["hex"]
+        txid = node.sendrawtransaction(signed_tx)
+
+    while (node.getmempoolinfo()['size'] > 0):
+        node.generate(1)
+
+    utxos = node.listunspent()
+    assert(len(utxos) >= count)
+    return utxos
+
+# Create large OP_RETURN txouts that can be appended to a transaction
+# to make it large (helper for constructing large transactions).
+def gen_return_txouts():
+    # Some pre-processing to create a bunch of OP_RETURN txouts to insert into transactions we create
+    # So we have big transactions (and therefore can't fit very many into each block)
+    # create one script_pubkey
+    script_pubkey = "6a4d0200" #OP_RETURN OP_PUSH2 512 bytes
+    for i in range (512):
+        script_pubkey = script_pubkey + "01"
+    # concatenate 128 txouts of above script_pubkey which we'll insert before the txout for change
+    txouts = "81"
+    for k in range(128):
+        # add txout value
+        txouts = txouts + "0000000000000000"
+        # add length of script_pubkey
+        txouts = txouts + "fd0402"
+        # add script_pubkey
+        txouts = txouts + script_pubkey
+    return txouts
+
+def create_tx(node, coinbase, to_address, amount):
+    inputs = [{ "txid" : coinbase, "vout" : 0}]
+    outputs = { to_address : amount }
+    rawtx = node.createrawtransaction(inputs, outputs)
+    signresult = node.signrawtransaction(rawtx)
+    assert_equal(signresult["complete"], True)
+    return signresult["hex"]
+
+# Create a spend of each passed-in utxo, splicing in "txouts" to each raw
+# transaction to make it large.  See gen_return_txouts() above.
+def create_lots_of_big_transactions(node, txouts, utxos, fee):
+    addr = node.getnewaddress()
+    txids = []
+    for i in range(len(utxos)):
+        t = utxos.pop()
+        inputs = []
+        inputs.append({ "txid" : t["txid"], "vout" : t["vout"]})
+        outputs = {}
+        send_value = t['amount'] - fee
+        outputs[addr] = satoshi_round(send_value)
+        rawtx = node.createrawtransaction(inputs, outputs)
+        newtx = rawtx[0:92]
+        newtx = newtx + txouts
+        newtx = newtx + rawtx[94:]
+        signresult = node.signrawtransaction(newtx, None, None, "NONE")
+        txid = node.sendrawtransaction(signresult["hex"], True)
+        txids.append(txid)
+    return txids
+
+def get_bip9_status(node, key):
+    info = node.getblockchaininfo()
+    return info['bip9_softforks'][key]
+
+
+def slow_gen(node, count, sleep = 0.1):
+    total = count
+    blocks = []
+    while total > 0:
+        now = min(total, 10)
+        blocks.extend(node.generate(now))
+        total -= now
+        time.sleep(sleep)
+    return blocks

basicswap/interface/contrib/pivx_test_framework/authproxy.py

@@ -0,0 +1,180 @@
+# Copyright (c) 2011 Jeff Garzik
+#
+# Previous copyright, from python-jsonrpc/jsonrpc/proxy.py:
+#
+# Copyright (c) 2007 Jan-Klaas Kollhof
+#
+# This file is part of jsonrpc.
+#
+# jsonrpc is free software; you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License as published by
+# the Free Software Foundation; either version 2.1 of the License, or
+# (at your option) any later version.
+#
+# This software is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with this software; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+"""HTTP proxy for opening RPC connection to pivxd.
+
+AuthServiceProxy has the following improvements over python-jsonrpc's
+ServiceProxy class:
+
+- HTTP connections persist for the life of the AuthServiceProxy object
+  (if server supports HTTP/1.1)
+- sends protocol 'version', per JSON-RPC 1.1
+- sends proper, incrementing 'id'
+- sends Basic HTTP authentication headers
+- parses all JSON numbers that look like floats as Decimal
+- uses standard Python json lib
+"""
+
+import base64
+import decimal
+import http.client
+import json
+import logging
+import socket
+import time
+import urllib.parse
+
+HTTP_TIMEOUT = 300
+USER_AGENT = "AuthServiceProxy/0.1"
+
+log = logging.getLogger("BitcoinRPC")
+
+class JSONRPCException(Exception):
+    def __init__(self, rpc_error):
+        try:
+            errmsg = '%(message)s (%(code)i)' % rpc_error
+        except (KeyError, TypeError):
+            errmsg = ''
+        super().__init__(errmsg)
+        self.error = rpc_error
+
+
+def EncodeDecimal(o):
+    if isinstance(o, decimal.Decimal):
+        return str(o)
+    raise TypeError(repr(o) + " is not JSON serializable")
+
+class AuthServiceProxy():
+    __id_count = 0
+
+    # ensure_ascii: escape unicode as \uXXXX, passed to json.dumps
+    def __init__(self, service_url, service_name=None, timeout=HTTP_TIMEOUT, connection=None, ensure_ascii=True):
+        self.__service_url = service_url
+        self._service_name = service_name
+        self.ensure_ascii = ensure_ascii  # can be toggled on the fly by tests
+        self.__url = urllib.parse.urlparse(service_url)
+        port = 80 if self.__url.port is None else self.__url.port
+        user = None if self.__url.username is None else self.__url.username.encode('utf8')
+        passwd = None if self.__url.password is None else self.__url.password.encode('utf8')
+        authpair = user + b':' + passwd
+        self.__auth_header = b'Basic ' + base64.b64encode(authpair)
+
+        if connection:
+            # Callables re-use the connection of the original proxy
+            self.__conn = connection
+        elif self.__url.scheme == 'https':
+            self.__conn = http.client.HTTPSConnection(self.__url.hostname, port, timeout=timeout)
+        else:
+            self.__conn = http.client.HTTPConnection(self.__url.hostname, port, timeout=timeout)
+
+    def __getattr__(self, name):
+        if name.startswith('__') and name.endswith('__'):
+            # Python internal stuff
+            raise AttributeError
+        if self._service_name is not None:
+            name = "%s.%s" % (self._service_name, name)
+        return AuthServiceProxy(self.__service_url, name, connection=self.__conn)
+
+    def _request(self, method, path, postdata):
+        '''
+        Do a HTTP request, with retry if we get disconnected (e.g. due to a timeout).
+        This is a workaround for https://bugs.python.org/issue3566 which is fixed in Python 3.5.
+        '''
+        headers = {'Host': self.__url.hostname,
+                   'User-Agent': USER_AGENT,
+                   'Authorization': self.__auth_header,
+                   'Content-type': 'application/json'}
+        try:
+            self.__conn.request(method, path, postdata, headers)
+            return self._get_response()
+        except http.client.BadStatusLine as e:
+            if e.line == "''":  # if connection was closed, try again
+                self.__conn.close()
+                self.__conn.request(method, path, postdata, headers)
+                return self._get_response()
+            else:
+                raise
+        except (BrokenPipeError, ConnectionResetError):
+            # Python 3.5+ raises BrokenPipeError instead of BadStatusLine when the connection was reset
+            # ConnectionResetError happens on FreeBSD with Python 3.4
+            self.__conn.close()
+            self.__conn.request(method, path, postdata, headers)
+            return self._get_response()
+
+    def get_request(self, *args, **argsn):
+        AuthServiceProxy.__id_count += 1
+
+        log.debug("-%s-> %s %s" % (AuthServiceProxy.__id_count, self._service_name,
+                                   json.dumps(args, default=EncodeDecimal, ensure_ascii=self.ensure_ascii)))
+        if args and argsn:
+            raise ValueError('Cannot handle both named and positional arguments')
+        return {'version': '1.1',
+                'method': self._service_name,
+                'params': args or argsn,
+                'id': AuthServiceProxy.__id_count}
+
+    def __call__(self, *args, **argsn):
+        postdata = json.dumps(self.get_request(*args, **argsn), default=EncodeDecimal, ensure_ascii=self.ensure_ascii)
+        response = self._request('POST', self.__url.path, postdata.encode('utf-8'))
+        if response['error'] is not None:
+            raise JSONRPCException(response['error'])
+        elif 'result' not in response:
+            raise JSONRPCException({
+                'code': -343, 'message': 'missing JSON-RPC result'})
+        else:
+            return response['result']
+
+    def batch(self, rpc_call_list):
+        postdata = json.dumps(list(rpc_call_list), default=EncodeDecimal, ensure_ascii=self.ensure_ascii)
+        log.debug("--> " + postdata)
+        return self._request('POST', self.__url.path, postdata.encode('utf-8'))
+
+    def _get_response(self):
+        req_start_time = time.time()
+        try:
+            http_response = self.__conn.getresponse()
+        except socket.timeout:
+            raise JSONRPCException({
+                'code': -344,
+                'message': '%r RPC took longer than %f seconds. Consider '
+                           'using larger timeout for calls that take '
+                           'longer to return.' % (self._service_name,
+                                                  self.__conn.timeout)})
+        if http_response is None:
+            raise JSONRPCException({
+                'code': -342, 'message': 'missing HTTP response from server'})
+
+        content_type = http_response.getheader('Content-Type')
+        if content_type != 'application/json':
+            raise JSONRPCException({
+                'code': -342, 'message': 'non-JSON HTTP response with \'%i %s\' from server' % (http_response.status, http_response.reason)})
+
+        responsedata = http_response.read().decode('utf8')
+        response = json.loads(responsedata, parse_float=decimal.Decimal)
+        elapsed = time.time() - req_start_time
+        if "error" in response and response["error"] is None:
+            log.debug("<-%s- [%.6f] %s" % (response["id"], elapsed, json.dumps(response["result"], default=EncodeDecimal, ensure_ascii=self.ensure_ascii)))
+        else:
+            log.debug("<-- [%.6f] %s" % (elapsed, responsedata))
+        return response
+
+    def __truediv__(self, relative_uri):
+        return AuthServiceProxy("{}/{}".format(self.__service_url, relative_uri), self._service_name, connection=self.__conn)

basicswap/interface/contrib/pivx_test_framework/coverage.py

@@ -0,0 +1,109 @@
+#!/usr/bin/env python3
+# Copyright (c) 2015-2017 The Bitcoin Core developers
+# Distributed under the MIT software license, see the accompanying
+# file COPYING or http://www.opensource.org/licenses/mit-license.php.
+"""Utilities for doing coverage analysis on the RPC interface.
+
+Provides a way to track which RPC commands are exercised during
+testing.
+"""
+
+import os
+
+
+REFERENCE_FILENAME = 'rpc_interface.txt'
+
+
+class AuthServiceProxyWrapper():
+    """
+    An object that wraps AuthServiceProxy to record specific RPC calls.
+
+    """
+    def __init__(self, auth_service_proxy_instance, coverage_logfile=None):
+        """
+        Kwargs:
+            auth_service_proxy_instance (AuthServiceProxy): the instance
+                being wrapped.
+            coverage_logfile (str): if specified, write each service_name
+                out to a file when called.
+
+        """
+        self.auth_service_proxy_instance = auth_service_proxy_instance
+        self.coverage_logfile = coverage_logfile
+
+    def __getattr__(self, name):
+        return_val = getattr(self.auth_service_proxy_instance, name)
+        if not isinstance(return_val, type(self.auth_service_proxy_instance)):
+            # If proxy getattr returned an unwrapped value, do the same here.
+            return return_val
+        return AuthServiceProxyWrapper(return_val, self.coverage_logfile)
+
+    def __call__(self, *args, **kwargs):
+        """
+        Delegates to AuthServiceProxy, then writes the particular RPC method
+        called to a file.
+
+        """
+        return_val = self.auth_service_proxy_instance.__call__(*args, **kwargs)
+        self._log_call()
+        return return_val
+
+    def _log_call(self):
+        rpc_method = self.auth_service_proxy_instance._service_name
+
+        if self.coverage_logfile:
+            with open(self.coverage_logfile, 'a+', encoding='utf8') as f:
+                f.write("%s\n" % rpc_method)
+
+    def __truediv__(self, relative_uri):
+        return AuthServiceProxyWrapper(self.auth_service_proxy_instance / relative_uri,
+                                       self.coverage_logfile)
+
+    def get_request(self, *args, **kwargs):
+        self._log_call()
+        return self.auth_service_proxy_instance.get_request(*args)
+
+def get_filename(dirname, n_node):
+    """
+    Get a filename unique to the test process ID and node.
+
+    This file will contain a list of RPC commands covered.
+    """
+    pid = str(os.getpid())
+    return os.path.join(
+        dirname, "coverage.pid%s.node%s.txt" % (pid, str(n_node)))
+
+
+def write_all_rpc_commands(dirname, node):
+    """
+    Write out a list of all RPC functions available in `pivx-cli` for
+    coverage comparison. This will only happen once per coverage
+    directory.
+
+    Args:
+        dirname (str): temporary test dir
+        node (AuthServiceProxy): client
+
+    Returns:
+        bool. if the RPC interface file was written.
+
+    """
+    filename = os.path.join(dirname, REFERENCE_FILENAME)
+
+    if os.path.isfile(filename):
+        return False
+
+    help_output = node.help().split('\n')
+    commands = set()
+
+    for line in help_output:
+        line = line.strip()
+
+        # Ignore blanks and headers
+        if line and not line.startswith('='):
+            commands.add("%s\n" % line.split()[0])
+
+    with open(filename, 'w', encoding='utf8') as f:
+        f.writelines(list(commands))
+
+    return True

basicswap/interface/contrib/pivx_test_framework/siphash.py

@@ -0,0 +1,63 @@
+#!/usr/bin/env python3
+# Copyright (c) 2016-2017 The Bitcoin Core developers
+# Distributed under the MIT software license, see the accompanying
+# file COPYING or http://www.opensource.org/licenses/mit-license.php.
+"""Specialized SipHash-2-4 implementations.
+
+This implements SipHash-2-4 for 256-bit integers.
+"""
+
+def rotl64(n, b):
+    return n >> (64 - b) | (n & ((1 << (64 - b)) - 1)) << b
+
+def siphash_round(v0, v1, v2, v3):
+    v0 = (v0 + v1) & ((1 << 64) - 1)
+    v1 = rotl64(v1, 13)
+    v1 ^= v0
+    v0 = rotl64(v0, 32)
+    v2 = (v2 + v3) & ((1 << 64) - 1)
+    v3 = rotl64(v3, 16)
+    v3 ^= v2
+    v0 = (v0 + v3) & ((1 << 64) - 1)
+    v3 = rotl64(v3, 21)
+    v3 ^= v0
+    v2 = (v2 + v1) & ((1 << 64) - 1)
+    v1 = rotl64(v1, 17)
+    v1 ^= v2
+    v2 = rotl64(v2, 32)
+    return (v0, v1, v2, v3)
+
+def siphash256(k0, k1, h):
+    n0 = h & ((1 << 64) - 1)
+    n1 = (h >> 64) & ((1 << 64) - 1)
+    n2 = (h >> 128) & ((1 << 64) - 1)
+    n3 = (h >> 192) & ((1 << 64) - 1)
+    v0 = 0x736f6d6570736575 ^ k0
+    v1 = 0x646f72616e646f6d ^ k1
+    v2 = 0x6c7967656e657261 ^ k0
+    v3 = 0x7465646279746573 ^ k1 ^ n0
+    v0, v1, v2, v3 = siphash_round(v0, v1, v2, v3)
+    v0, v1, v2, v3 = siphash_round(v0, v1, v2, v3)
+    v0 ^= n0
+    v3 ^= n1
+    v0, v1, v2, v3 = siphash_round(v0, v1, v2, v3)
+    v0, v1, v2, v3 = siphash_round(v0, v1, v2, v3)
+    v0 ^= n1
+    v3 ^= n2
+    v0, v1, v2, v3 = siphash_round(v0, v1, v2, v3)
+    v0, v1, v2, v3 = siphash_round(v0, v1, v2, v3)
+    v0 ^= n2
+    v3 ^= n3
+    v0, v1, v2, v3 = siphash_round(v0, v1, v2, v3)
+    v0, v1, v2, v3 = siphash_round(v0, v1, v2, v3)
+    v0 ^= n3
+    v3 ^= 0x2000000000000000
+    v0, v1, v2, v3 = siphash_round(v0, v1, v2, v3)
+    v0, v1, v2, v3 = siphash_round(v0, v1, v2, v3)
+    v0 ^= 0x2000000000000000
+    v2 ^= 0xFF
+    v0, v1, v2, v3 = siphash_round(v0, v1, v2, v3)
+    v0, v1, v2, v3 = siphash_round(v0, v1, v2, v3)
+    v0, v1, v2, v3 = siphash_round(v0, v1, v2, v3)
+    v0, v1, v2, v3 = siphash_round(v0, v1, v2, v3)
+    return v0 ^ v1 ^ v2 ^ v3

basicswap/interface/contrib/pivx_test_framework/util.py

@@ -0,0 +1,625 @@
+#!/usr/bin/env python3
+# Copyright (c) 2014-2017 The Bitcoin Core developers
+# Distributed under the MIT software license, see the accompanying
+# file COPYING or http://www.opensource.org/licenses/mit-license.php.
+"""Helpful routines for regression testing."""
+
+from base64 import b64encode
+from binascii import hexlify, unhexlify
+from decimal import Decimal, ROUND_DOWN
+import hashlib
+import json
+import logging
+import os
+import random
+import re
+from subprocess import CalledProcessError
+import time
+
+from . import coverage, messages
+from .authproxy import AuthServiceProxy, JSONRPCException
+
+logger = logging.getLogger("TestFramework.utils")
+
+# Assert functions
+##################
+
+def assert_fee_amount(fee, tx_size, fee_per_kB):
+    """Assert the fee was in range"""
+    target_fee = round(tx_size * fee_per_kB / 1000, 8)
+    if fee < target_fee:
+        raise AssertionError("Fee of %s PIV too low! (Should be %s PIV)" % (str(fee), str(target_fee)))
+    # allow the wallet's estimation to be at most 2 bytes off
+    if fee > (tx_size + 20) * fee_per_kB / 1000:
+        raise AssertionError("Fee of %s PIV too high! (Should be %s PIV)" % (str(fee), str(target_fee)))
+
+def assert_equal(thing1, thing2, *args):
+    if thing1 != thing2 or any(thing1 != arg for arg in args):
+        raise AssertionError("not(%s)" % " == ".join(str(arg) for arg in (thing1, thing2) + args))
+
+def assert_true(condition, message = ""):
+    if not condition:
+        raise AssertionError(message)
+
+def assert_false(condition, message = ""):
+    assert_true(not condition, message)
+
+def assert_greater_than(thing1, thing2):
+    if thing1 <= thing2:
+        raise AssertionError("%s <= %s" % (str(thing1), str(thing2)))
+
+def assert_greater_than_or_equal(thing1, thing2):
+    if thing1 < thing2:
+        raise AssertionError("%s < %s" % (str(thing1), str(thing2)))
+
+def assert_raises(exc, fun, *args, **kwds):
+    assert_raises_message(exc, None, fun, *args, **kwds)
+
+def assert_raises_message(exc, message, fun, *args, **kwds):
+    try:
+        fun(*args, **kwds)
+    except JSONRPCException:
+        raise AssertionError("Use assert_raises_rpc_error() to test RPC failures")
+    except exc as e:
+        if message is not None and message not in e.error['message']:
+            raise AssertionError("Expected substring not found:" + e.error['message'])
+    except Exception as e:
+        raise AssertionError("Unexpected exception raised: " + type(e).__name__)
+    else:
+        raise AssertionError("No exception raised")
+
+def assert_raises_process_error(returncode, output, fun, *args, **kwds):
+    """Execute a process and asserts the process return code and output.
+
+    Calls function `fun` with arguments `args` and `kwds`. Catches a CalledProcessError
+    and verifies that the return code and output are as expected. Throws AssertionError if
+    no CalledProcessError was raised or if the return code and output are not as expected.
+
+    Args:
+        returncode (int): the process return code.
+        output (string): [a substring of] the process output.
+        fun (function): the function to call. This should execute a process.
+        args*: positional arguments for the function.
+        kwds**: named arguments for the function.
+    """
+    try:
+        fun(*args, **kwds)
+    except CalledProcessError as e:
+        if returncode != e.returncode:
+            raise AssertionError("Unexpected returncode %i" % e.returncode)
+        if output not in e.output:
+            raise AssertionError("Expected substring not found:" + e.output)
+    else:
+        raise AssertionError("No exception raised")
+
+def assert_raises_rpc_error(code, message, fun, *args, **kwds):
+    """Run an RPC and verify that a specific JSONRPC exception code and message is raised.
+
+    Calls function `fun` with arguments `args` and `kwds`. Catches a JSONRPCException
+    and verifies that the error code and message are as expected. Throws AssertionError if
+    no JSONRPCException was raised or if the error code/message are not as expected.
+
+    Args:
+        code (int), optional: the error code returned by the RPC call (defined
+            in src/rpc/protocol.h). Set to None if checking the error code is not required.
+        message (string), optional: [a substring of] the error string returned by the
+            RPC call. Set to None if checking the error string is not required.
+        fun (function): the function to call. This should be the name of an RPC.
+        args*: positional arguments for the function.
+        kwds**: named arguments for the function.
+    """
+    assert try_rpc(code, message, fun, *args, **kwds), "No exception raised"
+
+def try_rpc(code, message, fun, *args, **kwds):
+    """Tries to run an rpc command.
+
+    Test against error code and message if the rpc fails.
+    Returns whether a JSONRPCException was raised."""
+    try:
+        fun(*args, **kwds)
+    except JSONRPCException as e:
+        # JSONRPCException was thrown as expected. Check the code and message values are correct.
+        if (code is not None) and (code != e.error["code"]):
+            raise AssertionError("Unexpected JSONRPC error code %i" % e.error["code"])
+        if (message is not None) and (message not in e.error['message']):
+            raise AssertionError("Expected substring (%s) not found in: %s" % (message, e.error['message']))
+        return True
+    except Exception as e:
+        raise AssertionError("Unexpected exception raised: " + type(e).__name__)
+    else:
+        return False
+
+def assert_is_hex_string(string):
+    try:
+        int(string, 16)
+    except Exception as e:
+        raise AssertionError(
+            "Couldn't interpret %r as hexadecimal; raised: %s" % (string, e))
+
+def assert_is_hash_string(string, length=64):
+    if not isinstance(string, str):
+        raise AssertionError("Expected a string, got type %r" % type(string))
+    elif length and len(string) != length:
+        raise AssertionError(
+            "String of length %d expected; got %d" % (length, len(string)))
+    elif not re.match('[abcdef0-9]+$', string):
+        raise AssertionError(
+            "String %r contains invalid characters for a hash." % string)
+
+def assert_array_result(object_array, to_match, expected, should_not_find=False):
+    """
+        Pass in array of JSON objects, a dictionary with key/value pairs
+        to match against, and another dictionary with expected key/value
+        pairs.
+        If the should_not_find flag is true, to_match should not be found
+        in object_array
+        """
+    if should_not_find:
+        assert_equal(expected, {})
+    num_matched = 0
+    for item in object_array:
+        all_match = True
+        for key, value in to_match.items():
+            if item[key] != value:
+                all_match = False
+        if not all_match:
+            continue
+        elif should_not_find:
+            num_matched = num_matched + 1
+        for key, value in expected.items():
+            if item[key] != value:
+                raise AssertionError("%s : expected %s=%s" % (str(item), str(key), str(value)))
+            num_matched = num_matched + 1
+    if num_matched == 0 and not should_not_find:
+        raise AssertionError("No objects matched %s" % (str(to_match)))
+    if num_matched > 0 and should_not_find:
+        raise AssertionError("Objects were found %s" % (str(to_match)))
+
+# Utility functions
+###################
+
+def check_json_precision():
+    """Make sure json library being used does not lose precision converting BTC values"""
+    n = Decimal("20000000.00000003")
+    satoshis = int(json.loads(json.dumps(float(n))) * 1.0e8)
+    if satoshis != 2000000000000003:
+        raise RuntimeError("JSON encode/decode loses precision")
+
+def count_bytes(hex_string):
+    return len(bytearray.fromhex(hex_string))
+
+def bytes_to_hex_str(byte_str):
+    return hexlify(byte_str).decode('ascii')
+
+def hash256(byte_str):
+    sha256 = hashlib.sha256()
+    sha256.update(byte_str)
+    sha256d = hashlib.sha256()
+    sha256d.update(sha256.digest())
+    return sha256d.digest()[::-1]
+
+def hex_str_to_bytes(hex_str):
+    return unhexlify(hex_str.encode('ascii'))
+
+def str_to_b64str(string):
+    return b64encode(string.encode('utf-8')).decode('ascii')
+
+def satoshi_round(amount):
+    return Decimal(amount).quantize(Decimal('0.00000001'), rounding=ROUND_DOWN)
+
+def wait_until(predicate,
+               *,
+               attempts=float('inf'),
+               timeout=float('inf'),
+               lock=None,
+               sendpings=None,
+               mocktime=None):
+
+    if attempts == float('inf') and timeout == float('inf'):
+        timeout = 60
+    attempt = 0
+    timeout += time.time()
+
+    while attempt < attempts and time.time() < timeout:
+        if lock:
+            with lock:
+                if predicate():
+                    return
+        else:
+            if predicate():
+                return
+        attempt += 1
+        time.sleep(0.5)
+        if sendpings is not None:
+            sendpings()
+        if mocktime is not None:
+            mocktime(1)
+
+    # Print the cause of the timeout
+    assert_greater_than(attempts, attempt)
+    assert_greater_than(timeout, time.time())
+    raise RuntimeError('Unreachable')
+
+# RPC/P2P connection constants and functions
+############################################
+
+# The maximum number of nodes a single test can spawn
+MAX_NODES = 8
+# Don't assign rpc or p2p ports lower than this
+PORT_MIN = 11000
+# The number of ports to "reserve" for p2p and rpc, each
+PORT_RANGE = 5000
+
+class PortSeed:
+    # Must be initialized with a unique integer for each process
+    n = None
+
+def get_rpc_proxy(url, node_number, timeout=None, coveragedir=None):
+    """
+    Args:
+        url (str): URL of the RPC server to call
+        node_number (int): the node number (or id) that this calls to
+
+    Kwargs:
+        timeout (int): HTTP timeout in seconds
+
+    Returns:
+        AuthServiceProxy. convenience object for making RPC calls.
+
+    """
+    proxy_kwargs = {}
+    if timeout is not None:
+        proxy_kwargs['timeout'] = timeout
+
+    proxy = AuthServiceProxy(url, **proxy_kwargs)
+    proxy.url = url  # store URL on proxy for info
+
+    coverage_logfile = coverage.get_filename(
+        coveragedir, node_number) if coveragedir else None
+
+    return coverage.AuthServiceProxyWrapper(proxy, coverage_logfile)
+
+def p2p_port(n):
+    assert(n <= MAX_NODES)
+    return PORT_MIN + n + (MAX_NODES * PortSeed.n) % (PORT_RANGE - 1 - MAX_NODES)
+
+def rpc_port(n):
+    return PORT_MIN + PORT_RANGE + n + (MAX_NODES * PortSeed.n) % (PORT_RANGE - 1 - MAX_NODES)
+
+def rpc_url(datadir, i, rpchost=None):
+    rpc_u, rpc_p = get_auth_cookie(datadir)
+    host = '127.0.0.1'
+    port = rpc_port(i)
+    if rpchost:
+        parts = rpchost.split(':')
+        if len(parts) == 2:
+            host, port = parts
+        else:
+            host = rpchost
+    return "http://%s:%s@%s:%d" % (rpc_u, rpc_p, host, int(port))
+
+# Node functions
+################
+
+def initialize_datadir(dirname, n):
+    datadir = get_datadir_path(dirname, n)
+    if not os.path.isdir(datadir):
+        os.makedirs(datadir)
+    with open(os.path.join(datadir, "pivx.conf"), 'w', encoding='utf8') as f:
+        f.write("regtest=1\n")
+        f.write("[regtest]\n")
+        f.write("port=" + str(p2p_port(n)) + "\n")
+        f.write("rpcport=" + str(rpc_port(n)) + "\n")
+        f.write("server=1\n")
+        f.write("keypool=1\n")
+        f.write("discover=0\n")
+        f.write("listenonion=0\n")
+        f.write("spendzeroconfchange=1\n")
+        f.write("printtoconsole=0\n")
+        f.write("natpmp=0\n")
+    return datadir
+
+def get_datadir_path(dirname, n):
+    return os.path.join(dirname, "node" + str(n))
+
+def append_config(dirname, n, options):
+    datadir = get_datadir_path(dirname, n)
+    with open(os.path.join(datadir, "pivx.conf"), 'a', encoding='utf8') as f:
+        for option in options:
+            f.write(option + "\n")
+
+def get_auth_cookie(datadir):
+    user = None
+    password = None
+    if os.path.isfile(os.path.join(datadir, "pivx.conf")):
+        with open(os.path.join(datadir, "pivx.conf"), 'r', encoding='utf8') as f:
+            for line in f:
+                if line.startswith("rpcuser="):
+                    assert user is None  # Ensure that there is only one rpcuser line
+                    user = line.split("=")[1].strip("\n")
+                if line.startswith("rpcpassword="):
+                    assert password is None  # Ensure that there is only one rpcpassword line
+                    password = line.split("=")[1].strip("\n")
+    if os.path.isfile(os.path.join(datadir, "regtest", ".cookie")):
+        with open(os.path.join(datadir, "regtest", ".cookie"), 'r', encoding="utf8") as f:
+            userpass = f.read()
+            split_userpass = userpass.split(':')
+            user = split_userpass[0]
+            password = split_userpass[1]
+    if user is None or password is None:
+        raise ValueError("No RPC credentials")
+    return user, password
+
+# If a cookie file exists in the given datadir, delete it.
+def delete_cookie_file(datadir):
+    if os.path.isfile(os.path.join(datadir, "regtest", ".cookie")):
+        logger.debug("Deleting leftover cookie file")
+        os.remove(os.path.join(datadir, "regtest", ".cookie"))
+
+def get_bip9_status(node, key):
+    info = node.getblockchaininfo()
+    return info['bip9_softforks'][key]
+
+def set_node_times(nodes, t):
+    for node in nodes:
+        node.setmocktime(t)
+
+def disconnect_nodes(from_connection, node_num):
+    for addr in [peer['addr'] for peer in from_connection.getpeerinfo() if "testnode%d" % node_num in peer['subver']]:
+        try:
+            from_connection.disconnectnode(addr)
+        except JSONRPCException as e:
+            # If this node is disconnected between calculating the peer id
+            # and issuing the disconnect, don't worry about it.
+            # This avoids a race condition if we're mass-disconnecting peers.
+            if e.error['code'] != -29: # RPC_CLIENT_NODE_NOT_CONNECTED
+                raise
+
+    # wait to disconnect
+    wait_until(lambda: [peer['addr'] for peer in from_connection.getpeerinfo() if "testnode%d" % node_num in peer['subver']] == [], timeout=5)
+
+def connect_nodes(from_connection, node_num):
+    ip_port = "127.0.0.1:" + str(p2p_port(node_num))
+    from_connection.addnode(ip_port, "onetry")
+    # poll until version handshake complete to avoid race conditions
+    # with transaction relaying
+    wait_until(lambda:  all(peer['version'] != 0 for peer in from_connection.getpeerinfo()))
+
+def connect_nodes_clique(nodes):
+    l = len(nodes)
+    for a in range(l):
+        for b in range(a, l):
+            connect_nodes(nodes[a], b)
+            connect_nodes(nodes[b], a)
+
+# Transaction/Block functions
+#############################
+
+def find_output(node, txid, amount):
+    """
+    Return index to output of txid with value amount
+    Raises exception if there is none.
+    """
+    txdata = node.getrawtransaction(txid, 1)
+    for i in range(len(txdata["vout"])):
+        if txdata["vout"][i]["value"] == amount:
+            return i
+    raise RuntimeError("find_output txid %s : %s not found" % (txid, str(amount)))
+
+def gather_inputs(from_node, amount_needed, confirmations_required=1):
+    """
+    Return a random set of unspent txouts that are enough to pay amount_needed
+    """
+    assert(confirmations_required >= 0)
+    utxo = from_node.listunspent(confirmations_required)
+    random.shuffle(utxo)
+    inputs = []
+    total_in = Decimal("0.00000000")
+    while total_in < amount_needed and len(utxo) > 0:
+        t = utxo.pop()
+        total_in += t["amount"]
+        inputs.append({"txid": t["txid"], "vout": t["vout"], "address": t["address"]})
+    if total_in < amount_needed:
+        raise RuntimeError("Insufficient funds: need %d, have %d" % (amount_needed, total_in))
+    return (total_in, inputs)
+
+def make_change(from_node, amount_in, amount_out, fee):
+    """
+    Create change output(s), return them
+    """
+    outputs = {}
+    amount = amount_out + fee
+    change = amount_in - amount
+    if change > amount * 2:
+        # Create an extra change output to break up big inputs
+        change_address = from_node.getnewaddress()
+        # Split change in two, being careful of rounding:
+        outputs[change_address] = Decimal(change / 2).quantize(Decimal('0.00000001'), rounding=ROUND_DOWN)
+        change = amount_in - amount - outputs[change_address]
+    if change > 0:
+        outputs[from_node.getnewaddress()] = change
+    return outputs
+
+def random_transaction(nodes, amount, min_fee, fee_increment, fee_variants):
+    """
+    Create a random transaction.
+    Returns (txid, hex-encoded-transaction-data, fee)
+    """
+    from_node = random.choice(nodes)
+    to_node = random.choice(nodes)
+    fee = min_fee + fee_increment * random.randint(0, fee_variants)
+
+    (total_in, inputs) = gather_inputs(from_node, amount + fee)
+    outputs = make_change(from_node, total_in, amount, fee)
+    outputs[to_node.getnewaddress()] = float(amount)
+
+    rawtx = from_node.createrawtransaction(inputs, outputs)
+    signresult = from_node.signrawtransaction(rawtx)
+    txid = from_node.sendrawtransaction(signresult["hex"], True)
+
+    return (txid, signresult["hex"], fee)
+
+# Helper to create at least "count" utxos
+# Pass in a fee that is sufficient for relay and mining new transactions.
+def create_confirmed_utxos(fee, node, count):
+    to_generate = int(0.5 * count) + 101
+    while to_generate > 0:
+        node.generate(min(25, to_generate))
+        to_generate -= 25
+    utxos = node.listunspent()
+    iterations = count - len(utxos)
+    addr1 = node.getnewaddress()
+    addr2 = node.getnewaddress()
+    if iterations <= 0:
+        return utxos
+    for i in range(iterations):
+        t = utxos.pop()
+        inputs = []
+        inputs.append({"txid": t["txid"], "vout": t["vout"]})
+        outputs = {}
+        send_value = t['amount'] - fee
+        outputs[addr1] = float(satoshi_round(send_value / 2))
+        outputs[addr2] = float(satoshi_round(send_value / 2))
+        raw_tx = node.createrawtransaction(inputs, outputs)
+        signed_tx = node.signrawtransaction(raw_tx)["hex"]
+        node.sendrawtransaction(signed_tx)
+
+    while (node.getmempoolinfo()['size'] > 0):
+        node.generate(1)
+
+    utxos = node.listunspent()
+    assert(len(utxos) >= count)
+    return utxos
+
+# Create large OP_RETURN txouts that can be appended to a transaction
+# to make it large (helper for constructing large transactions).
+def gen_return_txouts():
+    # Some pre-processing to create a bunch of OP_RETURN txouts to insert into transactions we create
+    # So we have big transactions (and therefore can't fit very many into each block)
+    # create one script_pubkey
+    script_pubkey = "6a4d0200"  # OP_RETURN OP_PUSH2 512 bytes
+    for i in range(512):
+        script_pubkey = script_pubkey + "01"
+    # concatenate 128 txouts of above script_pubkey which we'll insert before the txout for change
+    txouts = "81"
+    for k in range(128):
+        # add txout value
+        txouts = txouts + "0000000000000000"
+        # add length of script_pubkey
+        txouts = txouts + "fd0402"
+        # add script_pubkey
+        txouts = txouts + script_pubkey
+    return txouts
+
+def create_tx(node, coinbase, to_address, amount):
+    inputs = [{"txid": coinbase, "vout": 0}]
+    outputs = {to_address: amount}
+    rawtx = node.createrawtransaction(inputs, outputs)
+    signresult = node.signrawtransaction(rawtx)
+    assert_equal(signresult["complete"], True)
+    return signresult["hex"]
+
+# Create a spend of each passed-in utxo, splicing in "txouts" to each raw
+# transaction to make it large.  See gen_return_txouts() above.
+def create_lots_of_big_transactions(node, txouts, utxos, num, fee):
+    addr = node.getnewaddress()
+    txids = []
+    for _ in range(num):
+        t = utxos.pop()
+        inputs = [{"txid": t["txid"], "vout": t["vout"]}]
+        outputs = {}
+        change = t['amount'] - fee
+        outputs[addr] = float(satoshi_round(change))
+        rawtx = node.createrawtransaction(inputs, outputs)
+        newtx = rawtx[0:92]
+        newtx = newtx + txouts
+        newtx = newtx + rawtx[94:]
+        signresult = node.signrawtransaction(newtx, None, None, "NONE")
+        txid = node.sendrawtransaction(signresult["hex"], True)
+        txids.append(txid)
+    return txids
+
+def mine_large_block(node, utxos=None):
+    # generate a 66k transaction,
+    # and 14 of them is close to the 1MB block limit
+    num = 14
+    txouts = gen_return_txouts()
+    utxos = utxos if utxos is not None else []
+    if len(utxos) < num:
+        utxos.clear()
+        utxos.extend(node.listunspent())
+    fee = 100 * node.getnetworkinfo()["relayfee"]
+    create_lots_of_big_transactions(node, txouts, utxos, num, fee=fee)
+    node.generate(1)
+
+def find_vout_for_address(node, txid, addr):
+    """
+    Locate the vout index of the given transaction sending to the
+    given address. Raises runtime error exception if not found.
+    """
+    tx = node.getrawtransaction(txid, True)
+    for i in range(len(tx["vout"])):
+        if any([addr == a for a in tx["vout"][i]["scriptPubKey"]["addresses"]]):
+            return i
+    raise RuntimeError("Vout not found for address: txid=%s, addr=%s" % (txid, addr))
+
+# PIVX specific utils
+DEFAULT_FEE = 0.01
+SPORK_ACTIVATION_TIME = 1563253447
+SPORK_DEACTIVATION_TIME = 4070908800
+
+def DecimalAmt(x):
+    """Return Decimal from float for equality checks against rpc outputs"""
+    return Decimal("{:0.8f}".format(x))
+
+# Find a coinstake/coinbase address on the node, filtering by the number of UTXOs it has.
+# If no filter is provided, returns the coinstake/coinbase address on the node containing
+# the greatest number of spendable UTXOs.
+# The default cached chain has one address per coinbase output.
+def get_coinstake_address(node, expected_utxos=None):
+    addrs = [utxo['address'] for utxo in node.listunspent() if utxo['generated']]
+    assert(len(set(addrs)) > 0)
+
+    if expected_utxos is None:
+        addrs = [(addrs.count(a), a) for a in set(addrs)]
+        return sorted(addrs, reverse=True)[0][1]
+
+    addrs = [a for a in set(addrs) if addrs.count(a) == expected_utxos]
+    assert(len(addrs) > 0)
+    return addrs[0]
+
+# Deterministic masternodes
+def is_coin_locked_by(node, outpoint):
+    return outpoint.to_json() in node.listlockunspent()
+
+def get_collateral_vout(json_tx):
+    funding_txidn = -1
+    for o in json_tx["vout"]:
+        if o["value"] == Decimal('100'):
+            funding_txidn = o["n"]
+            break
+    assert_greater_than(funding_txidn, -1)
+    return funding_txidn
+
+# owner and voting keys are created from controller node.
+# operator keys are created, if operator_keys is None.
+def create_new_dmn(idx, controller, payout_addr, operator_keys):
+    port = p2p_port(idx) if idx <= MAX_NODES else p2p_port(MAX_NODES) + (idx - MAX_NODES)
+    ipport = "127.0.0.1:" + str(port)
+    owner_addr = controller.getnewaddress("mnowner-%d" % idx)
+    voting_addr = controller.getnewaddress("mnvoting-%d" % idx)
+    if operator_keys is None:
+        bls_keypair = controller.generateblskeypair()
+        operator_pk = bls_keypair["public"]
+        operator_sk = bls_keypair["secret"]
+    else:
+        operator_pk = operator_keys[0]
+        operator_sk = operator_keys[1]
+    return messages.Masternode(idx, owner_addr, operator_pk, voting_addr, ipport, payout_addr, operator_sk)
+
+def spend_mn_collateral(spender, dmn):
+    inputs = [dmn.collateral.to_json()]
+    outputs = {spender.getnewaddress(): Decimal('99.99')}
+    sig_res = spender.signrawtransaction(spender.createrawtransaction(inputs, outputs))
+    assert_equal(sig_res['complete'], True)
+    return spender.sendrawtransaction(sig_res['hex'])

basicswap/interface/dash.py

@@ -0,0 +1,94 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+# Copyright (c) 2022 tecnovert
+# Distributed under the MIT software license, see the accompanying
+# file LICENSE or http://www.opensource.org/licenses/mit-license.php.
+
+from .btc import BTCInterface
+from basicswap.chainparams import Coins
+from basicswap.util.address import decodeAddress
+from mnemonic import Mnemonic
+from basicswap.contrib.test_framework.script import (
+    CScript,
+    OP_DUP, OP_HASH160, OP_EQUALVERIFY, OP_CHECKSIG
+)
+
+
+class DASHInterface(BTCInterface):
+    @staticmethod
+    def coin_type():
+        return Coins.DASH
+
+    def __init__(self, coin_settings, network, swap_client=None):
+        super().__init__(coin_settings, network, swap_client)
+        self._wallet_passphrase = ''
+        self._have_checked_seed = False
+
+    def seedToMnemonic(self, key: bytes) -> str:
+        return Mnemonic('english').to_mnemonic(key)
+
+    def initialiseWallet(self, key: bytes):
+        words = self.seedToMnemonic(key)
+
+        mnemonic_passphrase = ''
+        self.rpc_wallet('upgradetohd', [words, mnemonic_passphrase, self._wallet_passphrase])
+        self._have_checked_seed = False
+        if self._wallet_passphrase != '':
+            self.unlockWallet(self._wallet_passphrase)
+
+    def decodeAddress(self, address: str) -> bytes:
+        return decodeAddress(address)[1:]
+
+    def checkExpectedSeed(self, key_hash: str):
+        try:
+            rv = self.rpc_wallet('dumphdinfo')
+            entropy = Mnemonic('english').to_entropy(rv['mnemonic'].split(' '))
+            entropy_hash = self.getAddressHashFromKey(entropy)[::-1].hex()
+            self._have_checked_seed = True
+            return entropy_hash == key_hash
+        except Exception as e:
+            self._log.warning('checkExpectedSeed failed: {}'.format(str(e)))
+        return False
+
+    def withdrawCoin(self, value, addr_to, subfee):
+        params = [addr_to, value, '', '', subfee, False, False, self._conf_target]
+        return self.rpc_wallet('sendtoaddress', params)
+
+    def getSpendableBalance(self) -> int:
+        return self.make_int(self.rpc_wallet('getwalletinfo')['balance'])
+
+    def getScriptForPubkeyHash(self, pkh: bytes) -> bytearray:
+        # Return P2PKH
+        return CScript([OP_DUP, OP_HASH160, pkh, OP_EQUALVERIFY, OP_CHECKSIG])
+
+    def getBLockSpendTxFee(self, tx, fee_rate: int) -> int:
+        add_bytes = 107
+        size = len(tx.serialize_with_witness()) + add_bytes
+        pay_fee = round(fee_rate * size / 1000)
+        self._log.info(f'BLockSpendTx  fee_rate, size, fee: {fee_rate}, {size}, {pay_fee}.')
+        return pay_fee
+
+    def findTxnByHash(self, txid_hex: str):
+        # Only works for wallet txns
+        try:
+            rv = self.rpc_wallet('gettransaction', [txid_hex])
+        except Exception as ex:
+            self._log.debug('findTxnByHash getrawtransaction failed: {}'.format(txid_hex))
+            return None
+        if 'confirmations' in rv and rv['confirmations'] >= self.blocks_confirmed:
+            block_height = self.getBlockHeader(rv['blockhash'])['height']
+            return {'txid': txid_hex, 'amount': 0, 'height': block_height}
+
+        return None
+
+    def unlockWallet(self, password: str):
+        super().unlockWallet(password)
+        # Store password for initialiseWallet
+        self._wallet_passphrase = password
+        if not self._have_checked_seed:
+            self._sc.checkWalletSeed(self.coin_type())
+
+    def lockWallet(self):
+        super().lockWallet()
+        self._wallet_passphrase = ''

basicswap/interface/firo.py

@@ -0,0 +1,367 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+# Copyright (c) 2022-2023 tecnovert
+# Distributed under the MIT software license, see the accompanying
+# file LICENSE or http://www.opensource.org/licenses/mit-license.php.
+
+import random
+import hashlib
+
+from .btc import BTCInterface, find_vout_for_address_from_txobj
+from basicswap.util import (
+    i2b,
+    ensure,
+)
+from basicswap.rpc import make_rpc_func
+from basicswap.util.crypto import hash160
+from basicswap.util.address import decodeAddress
+from basicswap.chainparams import Coins
+from basicswap.interface.contrib.firo_test_framework.script import (
+    CScript,
+    OP_DUP,
+    OP_EQUAL,
+    OP_HASH160,
+    OP_CHECKSIG,
+    OP_EQUALVERIFY,
+)
+from basicswap.interface.contrib.firo_test_framework.mininode import (
+    CBlock,
+    FromHex,
+    CTransaction,
+)
+
+
+class FIROInterface(BTCInterface):
+    @staticmethod
+    def coin_type():
+        return Coins.FIRO
+
+    def __init__(self, coin_settings, network, swap_client=None):
+        super(FIROInterface, self).__init__(coin_settings, network, swap_client)
+        # No multiwallet support
+        self.rpc_wallet = make_rpc_func(self._rpcport, self._rpcauth, host=self._rpc_host)
+
+    def checkWallets(self) -> int:
+        return 1
+
+    def getExchangeName(self, exchange_name):
+        return 'zcoin'
+
+    def initialiseWallet(self, key):
+        # load with -hdseed= parameter
+        pass
+
+    def getNewAddress(self, use_segwit, label='swap_receive'):
+        return self.rpc('getnewaddress', [label])
+        # addr_plain = self.rpc('getnewaddress', [label])
+        # return self.rpc('addwitnessaddress', [addr_plain])
+
+    def decodeAddress(self, address):
+        return decodeAddress(address)[1:]
+
+    def encodeSegwitAddress(self, script):
+        raise ValueError('TODO')
+
+    def decodeSegwitAddress(self, addr):
+        raise ValueError('TODO')
+
+    def isWatchOnlyAddress(self, address):
+        addr_info = self.rpc('validateaddress', [address])
+        return addr_info['iswatchonly']
+
+    def isAddressMine(self, address: str, or_watch_only: bool = False) -> bool:
+        addr_info = self.rpc('validateaddress', [address])
+        if not or_watch_only:
+            return addr_info['ismine']
+        return addr_info['ismine'] or addr_info['iswatchonly']
+
+    def getSCLockScriptAddress(self, lock_script):
+        lock_tx_dest = self.getScriptDest(lock_script)
+        address = self.encodeScriptDest(lock_tx_dest)
+
+        if not self.isAddressMine(address, or_watch_only=True):
+            # Expects P2WSH nested in BIP16_P2SH
+            ro = self.rpc('importaddress', [lock_tx_dest.hex(), 'bid lock', False, True])
+            addr_info = self.rpc('validateaddress', [address])
+
+        return address
+
+    def getLockTxHeight(self, txid, dest_address, bid_amount, rescan_from, find_index: bool = False):
+        # Add watchonly address and rescan if required
+
+        if not self.isAddressMine(dest_address, or_watch_only=True):
+            self.importWatchOnlyAddress(dest_address, 'bid')
+            self._log.info('Imported watch-only addr: {}'.format(dest_address))
+            self._log.info('Rescanning {} chain from height: {}'.format(self.coin_name(), rescan_from))
+            self.rescanBlockchainForAddress(rescan_from, dest_address)
+
+        return_txid = True if txid is None else False
+        if txid is None:
+            txns = self.rpc('listunspent', [0, 9999999, [dest_address, ]])
+
+            for tx in txns:
+                if self.make_int(tx['amount']) == bid_amount:
+                    txid = bytes.fromhex(tx['txid'])
+                    break
+
+        if txid is None:
+            return None
+
+        try:
+            tx = self.rpc('gettransaction', [txid.hex()])
+
+            block_height = 0
+            if 'blockhash' in tx:
+                block_header = self.rpc('getblockheader', [tx['blockhash']])
+                block_height = block_header['height']
+
+            rv = {
+                'depth': 0 if 'confirmations' not in tx else tx['confirmations'],
+                'height': block_height}
+
+        except Exception as e:
+            self._log.debug('getLockTxHeight gettransaction failed: %s, %s', txid.hex(), str(e))
+            return None
+
+        if find_index:
+            tx_obj = self.rpc('decoderawtransaction', [tx['hex']])
+            rv['index'] = find_vout_for_address_from_txobj(tx_obj, dest_address)
+
+        if return_txid:
+            rv['txid'] = txid.hex()
+
+        return rv
+
+    def createSCLockTx(self, value: int, script: bytearray, vkbv: bytes = None) -> bytes:
+        tx = CTransaction()
+        tx.nVersion = self.txVersion()
+        tx.vout.append(self.txoType()(value, self.getScriptDest(script)))
+
+        return tx.serialize()
+
+    def fundSCLockTx(self, tx_bytes, feerate, vkbv=None):
+        return self.fundTx(tx_bytes, feerate)
+
+    def signTxWithWallet(self, tx):
+        rv = self.rpc('signrawtransaction', [tx.hex()])
+        return bytes.fromhex(rv['hex'])
+
+    def createRawFundedTransaction(self, addr_to: str, amount: int, sub_fee: bool = False, lock_unspents: bool = True) -> str:
+        txn = self.rpc('createrawtransaction', [[], {addr_to: self.format_amount(amount)}])
+        fee_rate, fee_src = self.get_fee_rate(self._conf_target)
+        self._log.debug(f'Fee rate: {fee_rate}, source: {fee_src}, block target: {self._conf_target}')
+        options = {
+            'lockUnspents': lock_unspents,
+            'feeRate': fee_rate,
+        }
+        if sub_fee:
+            options['subtractFeeFromOutputs'] = [0,]
+        return self.rpc('fundrawtransaction', [txn, options])['hex']
+
+    def createRawSignedTransaction(self, addr_to, amount) -> str:
+        txn_funded = self.createRawFundedTransaction(addr_to, amount)
+        return self.rpc('signrawtransaction', [txn_funded])['hex']
+
+    def getScriptForPubkeyHash(self, pkh: bytes) -> bytearray:
+        # Return P2PKH
+        return CScript([OP_DUP, OP_HASH160, pkh, OP_EQUALVERIFY, OP_CHECKSIG])
+
+    def getScriptDest(self, script: bytearray) -> bytearray:
+        # P2SH
+
+        script_hash = hash160(script)
+        assert len(script_hash) == 20
+
+        return CScript([OP_HASH160, script_hash, OP_EQUAL])
+
+    def getSeedHash(self, seed: bytes) -> bytes:
+        return hash160(seed)[::-1]
+
+    def encodeScriptDest(self, script_dest: bytes) -> str:
+        # Extract hash from script
+        script_hash = script_dest[2:-1]
+        return self.sh_to_address(script_hash)
+
+    def getDestForScriptHash(self, script_hash):
+        assert len(script_hash) == 20
+        return CScript([OP_HASH160, script_hash, OP_EQUAL])
+
+    def withdrawCoin(self, value, addr_to, subfee):
+        params = [addr_to, value, '', '', subfee]
+        return self.rpc('sendtoaddress', params)
+
+    def getWalletSeedID(self):
+        return self.rpc('getwalletinfo')['hdmasterkeyid']
+
+    def getSpendableBalance(self) -> int:
+        return self.make_int(self.rpc('getwalletinfo')['balance'])
+
+    def getBLockSpendTxFee(self, tx, fee_rate: int) -> int:
+        add_bytes = 107
+        size = len(tx.serialize_with_witness()) + add_bytes
+        pay_fee = round(fee_rate * size / 1000)
+        self._log.info(f'BLockSpendTx  fee_rate, size, fee: {fee_rate}, {size}, {pay_fee}.')
+        return pay_fee
+
+    def signTxWithKey(self, tx: bytes, key: bytes) -> bytes:
+        key_wif = self.encodeKey(key)
+        rv = self.rpc('signrawtransaction', [tx.hex(), [], [key_wif, ]])
+        return bytes.fromhex(rv['hex'])
+
+    def findTxnByHash(self, txid_hex: str):
+        # Only works for wallet txns
+        try:
+            rv = self.rpc('gettransaction', [txid_hex])
+        except Exception as ex:
+            self._log.debug('findTxnByHash getrawtransaction failed: {}'.format(txid_hex))
+            return None
+        if 'confirmations' in rv and rv['confirmations'] >= self.blocks_confirmed:
+            block_height = self.getBlockHeader(rv['blockhash'])['height']
+            return {'txid': txid_hex, 'amount': 0, 'height': block_height}
+        return None
+
+    def getProofOfFunds(self, amount_for, extra_commit_bytes):
+        # TODO: Lock unspent and use same output/s to fund bid
+
+        unspents_by_addr = dict()
+        unspents = self.rpc('listunspent')
+        for u in unspents:
+            if u['spendable'] is not True:
+                continue
+            if u['address'] not in unspents_by_addr:
+                unspents_by_addr[u['address']] = {'total': 0, 'utxos': []}
+            utxo_amount: int = self.make_int(u['amount'], r=1)
+            unspents_by_addr[u['address']]['total'] += utxo_amount
+            unspents_by_addr[u['address']]['utxos'].append((utxo_amount, u['txid'], u['vout']))
+
+        max_utxos: int = 4
+
+        viable_addrs = []
+        for addr, data in unspents_by_addr.items():
+            if data['total'] >= amount_for:
+                # Sort from largest to smallest amount
+                sorted_utxos = sorted(data['utxos'], key=lambda x: x[0])
+
+                # Max outputs required to reach amount_for
+                utxos_req: int = 0
+                sum_value: int = 0
+                for utxo in sorted_utxos:
+                    sum_value += utxo[0]
+                    utxos_req += 1
+                    if sum_value >= amount_for:
+                        break
+
+                if utxos_req <= max_utxos:
+                    viable_addrs.append(addr)
+                    continue
+
+        ensure(len(viable_addrs) > 0, 'Could not find address with enough funds for proof')
+
+        sign_for_addr: str = random.choice(viable_addrs)
+        self._log.debug('sign_for_addr %s', sign_for_addr)
+
+        prove_utxos = []
+        sorted_utxos = sorted(unspents_by_addr[sign_for_addr]['utxos'], key=lambda x: x[0])
+
+        hasher = hashlib.sha256()
+
+        sum_value: int = 0
+        for utxo in sorted_utxos:
+            sum_value += utxo[0]
+            outpoint = (bytes.fromhex(utxo[1]), utxo[2])
+            prove_utxos.append(outpoint)
+            hasher.update(outpoint[0])
+            hasher.update(outpoint[1].to_bytes(2, 'big'))
+            if sum_value >= amount_for:
+                break
+        utxos_hash = hasher.digest()
+
+        self._log.debug('sign_for_addr %s', sign_for_addr)
+
+        if self.using_segwit():  # TODO: Use isSegwitAddress when scantxoutset can use combo
+            # 'Address does not refer to key' for non p2pkh
+            pkh = self.decodeAddress(sign_for_addr)
+            sign_for_addr = self.pkh_to_address(pkh)
+            self._log.debug('sign_for_addr converted %s', sign_for_addr)
+
+        signature = self.rpc('signmessage', [sign_for_addr, sign_for_addr + '_swap_proof_' + utxos_hash.hex() + extra_commit_bytes.hex()])
+
+        return (sign_for_addr, signature, prove_utxos)
+
+    def verifyProofOfFunds(self, address, signature, utxos, extra_commit_bytes):
+        hasher = hashlib.sha256()
+        sum_value: int = 0
+        for outpoint in utxos:
+            hasher.update(outpoint[0])
+            hasher.update(outpoint[1].to_bytes(2, 'big'))
+        utxos_hash = hasher.digest()
+
+        passed = self.verifyMessage(address, address + '_swap_proof_' + utxos_hash.hex() + extra_commit_bytes.hex(), signature)
+        ensure(passed is True, 'Proof of funds signature invalid')
+
+        if self.using_segwit():
+            address = self.encodeSegwitAddress(decodeAddress(address)[1:])
+
+        sum_value: int = 0
+        for outpoint in utxos:
+            txout = self.rpc('gettxout', [outpoint[0].hex(), outpoint[1]])
+            sum_value += self.make_int(txout['value'])
+
+        return sum_value
+
+    def rescanBlockchainForAddress(self, height_start: int, addr_find: str):
+        # Very ugly workaround for missing `rescanblockchain` rpc command
+
+        chain_blocks: int = self.getChainHeight()
+
+        current_height: int = chain_blocks
+        block_hash = self.rpc('getblockhash', [current_height])
+
+        script_hash: bytes = self.decodeAddress(addr_find)
+        find_scriptPubKey = self.getDestForScriptHash(script_hash)
+
+        while current_height > height_start:
+            block_hash = self.rpc('getblockhash', [current_height])
+
+            block = self.rpc('getblock', [block_hash, False])
+            decoded_block = CBlock()
+            decoded_block = FromHex(decoded_block, block)
+            for tx in decoded_block.vtx:
+                for txo in tx.vout:
+                    if txo.scriptPubKey == find_scriptPubKey:
+                        tx.rehash()
+                        txid = i2b(tx.sha256)
+                        self._log.info('Found output to addr: {} in tx {} in block {}'.format(addr_find, txid.hex(), block_hash))
+                        self._log.info('rescanblockchain hack invalidateblock {}'.format(block_hash))
+                        self.rpc('invalidateblock', [block_hash])
+                        self.rpc('reconsiderblock', [block_hash])
+                        return
+            current_height -= 1
+
+    def getBlockWithTxns(self, block_hash):
+        # TODO: Bypass decoderawtransaction and getblockheader
+        block = self.rpc('getblock', [block_hash, False])
+        block_header = self.rpc('getblockheader', [block_hash])
+        decoded_block = CBlock()
+        decoded_block = FromHex(decoded_block, block)
+
+        tx_rv = []
+        for tx in decoded_block.vtx:
+            tx_hex = tx.serialize_with_witness().hex()
+            tx_dec = self.rpc('decoderawtransaction', [tx_hex])
+            if 'hex' not in tx_dec:
+                tx_dec['hex'] = tx_hex
+
+            tx_rv.append(tx_dec)
+
+        block_rv = {
+            'hash': block_hash,
+            'tx': tx_rv,
+            'confirmations': block_header['confirmations'],
+            'height': block_header['height'],
+            'version': block_header['version'],
+            'merkleroot': block_header['merkleroot'],
+        }
+
+        return block_rv

basicswap/interface/ltc.py

@@ -0,0 +1,122 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+# Copyright (c) 2020-2023 tecnovert
+# Distributed under the MIT software license, see the accompanying
+# file LICENSE or http://www.opensource.org/licenses/mit-license.php.
+
+from .btc import BTCInterface
+from basicswap.rpc import make_rpc_func
+from basicswap.chainparams import Coins, chainparams
+
+
+class LTCInterface(BTCInterface):
+    @staticmethod
+    def coin_type():
+        return Coins.LTC
+
+    def __init__(self, coin_settings, network, swap_client=None):
+        super(LTCInterface, self).__init__(coin_settings, network, swap_client)
+        self._rpc_wallet_mweb = 'mweb'
+        self.rpc_wallet_mweb = make_rpc_func(self._rpcport, self._rpcauth, host=self._rpc_host, wallet=self._rpc_wallet_mweb)
+
+    def getNewMwebAddress(self, use_segwit=False, label='swap_receive') -> str:
+        return self.rpc_wallet_mweb('getnewaddress', [label, 'mweb'])
+
+    def getNewStealthAddress(self, label=''):
+        return self.getNewMwebAddress(False, label)
+
+    def withdrawCoin(self, value, type_from: str, addr_to: str, subfee: bool) -> str:
+        params = [addr_to, value, '', '', subfee, True, self._conf_target]
+        if type_from == 'mweb':
+            return self.rpc_wallet_mweb('sendtoaddress', params)
+        return self.rpc_wallet('sendtoaddress', params)
+
+    def getWalletInfo(self):
+        rv = super(LTCInterface, self).getWalletInfo()
+
+        mweb_info = self.rpc_wallet_mweb('getwalletinfo')
+        rv['mweb_balance'] = mweb_info['balance']
+        rv['mweb_unconfirmed'] = mweb_info['unconfirmed_balance']
+        rv['mweb_immature'] = mweb_info['immature_balance']
+
+        # Add unconfirmed mweb -> plain txns to the unconfirmed_balance
+        txns = self.rpc_wallet('listtransactions')
+        for tx in reversed(txns):
+            amount: float = tx.get('amount', 0.0)
+            if tx['confirmations'] == 0 and tx.get('mweb_out', None) and amount > 0.0:
+                rv['unconfirmed_balance'] += amount
+        return rv
+
+
+class LTCInterfaceMWEB(LTCInterface):
+    @staticmethod
+    def coin_type():
+        return Coins.LTC_MWEB
+
+    def __init__(self, coin_settings, network, swap_client=None):
+        super(LTCInterfaceMWEB, self).__init__(coin_settings, network, swap_client)
+        self._rpc_wallet = 'mweb'
+        self.rpc_wallet = make_rpc_func(self._rpcport, self._rpcauth, host=self._rpc_host, wallet=self._rpc_wallet)
+
+    def chainparams(self):
+        return chainparams[Coins.LTC]
+
+    def chainparams_network(self):
+        return chainparams[Coins.LTC][self._network]
+
+    def coin_name(self) -> str:
+        coin_chainparams = chainparams[Coins.LTC]
+        if coin_chainparams.get('use_ticker_as_name', False):
+            return coin_chainparams['ticker'] + ' MWEB'
+        return coin_chainparams['name'].capitalize() + ' MWEB'
+
+    def ticker(self) -> str:
+        ticker = chainparams[Coins.LTC]['ticker']
+        if self._network == 'testnet':
+            ticker = 't' + ticker
+        elif self._network == 'regtest':
+            ticker = 'rt' + ticker
+        return ticker + '_MWEB'
+
+    def getNewAddress(self, use_segwit=False, label='swap_receive') -> str:
+        return self.getNewMwebAddress()
+
+    def has_mweb_wallet(self) -> bool:
+        return 'mweb' in self.rpc('listwallets')
+
+    def init_wallet(self, password=None):
+        # If system is encrypted mweb wallet will be created at first unlock
+
+        self._log.info('init_wallet - {}'.format(self.ticker()))
+
+        self._log.info('Creating mweb wallet for {}.'.format(self.coin_name()))
+        # wallet_name, disable_private_keys, blank, passphrase, avoid_reuse, descriptors, load_on_startup
+        self.rpc('createwallet', ['mweb', False, True, password, False, False, True])
+
+        if password is not None:
+            # Max timeout value, ~3 years
+            self.rpc_wallet('walletpassphrase', [password, 100000000])
+
+        if self.getWalletSeedID() == 'Not found':
+            self._sc.initialiseWallet(self.coin_type())
+
+            # Workaround to trigger mweb_spk_man->LoadMWEBKeychain()
+            self.rpc('unloadwallet', ['mweb'])
+            self.rpc('loadwallet', ['mweb'])
+            if password is not None:
+                self.rpc_wallet('walletpassphrase', [password, 100000000])
+            self.rpc_wallet('keypoolrefill')
+
+    def unlockWallet(self, password: str):
+        if password == '':
+            return
+        self._log.info('unlockWallet - {}'.format(self.ticker()))
+
+        if not self.has_mweb_wallet():
+            self.init_wallet(password)
+        else:
+            # Max timeout value, ~3 years
+            self.rpc_wallet('walletpassphrase', [password, 100000000])
+
+        self._sc.checkWalletSeed(self.coin_type())

basicswap/interface/nav.py

@@ -0,0 +1,738 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+# Copyright (c) 2023 tecnovert
+# Distributed under the MIT software license, see the accompanying
+# file LICENSE or http://www.opensource.org/licenses/mit-license.php.
+
+import random
+import hashlib
+
+from io import BytesIO
+from coincurve.keys import (
+    PublicKey,
+    PrivateKey,
+)
+from .btc import BTCInterface, find_vout_for_address_from_txobj, findOutput
+from basicswap.rpc import make_rpc_func
+from basicswap.chainparams import Coins
+from basicswap.interface.contrib.nav_test_framework.mininode import (
+    CTxIn,
+    CTxOut,
+    CBlock,
+    COutPoint,
+    CTransaction,
+    CTxInWitness,
+    FromHex,
+    uint256_from_str,
+)
+from basicswap.util.crypto import hash160
+from basicswap.util.address import (
+    decodeWif,
+    pubkeyToAddress,
+    encodeAddress,
+)
+from basicswap.util import (
+    i2b, i2h,
+    ensure,
+)
+from basicswap.basicswap_util import (
+    getVoutByScriptPubKey,
+)
+
+from basicswap.interface.contrib.nav_test_framework.script import (
+    CScript,
+    OP_0,
+    OP_EQUAL,
+    OP_DUP, OP_HASH160, OP_EQUALVERIFY, OP_CHECKSIG,
+    SIGHASH_ALL,
+    SegwitVersion1SignatureHash,
+)
+from mnemonic import Mnemonic
+
+
+class NAVInterface(BTCInterface):
+    @staticmethod
+    def coin_type():
+        return Coins.NAV
+
+    @staticmethod
+    def txVersion() -> int:
+        return 3
+
+    @staticmethod
+    def txoType():
+        return CTxOut
+
+    def __init__(self, coin_settings, network, swap_client=None):
+        super(NAVInterface, self).__init__(coin_settings, network, swap_client)
+        # No multiwallet support
+        self.rpc_wallet = make_rpc_func(self._rpcport, self._rpcauth, host=self._rpc_host)
+
+    def checkWallets(self) -> int:
+        return 1
+
+    def use_p2shp2wsh(self) -> bool:
+        # p2sh-p2wsh
+        return True
+
+    def seedToMnemonic(self, key):
+        return Mnemonic('english').to_mnemonic(key)
+
+    def initialiseWallet(self, key):
+        # load with -importmnemonic= parameter
+        pass
+
+    def getWalletSeedID(self):
+        return self.rpc('getwalletinfo')['hdmasterkeyid']
+
+    def withdrawCoin(self, value, addr_to: str, subfee: bool):
+        strdzeel = ''
+        params = [addr_to, value, '', '', strdzeel, subfee]
+        return self.rpc('sendtoaddress', params)
+
+    def getSpendableBalance(self) -> int:
+        return self.make_int(self.rpc('getwalletinfo')['balance'])
+
+    def signTxWithWallet(self, tx: bytes) -> bytes:
+        rv = self.rpc('signrawtransaction', [tx.hex()])
+
+        return bytes.fromhex(rv['hex'])
+
+    def checkExpectedSeed(self, key_hash: str):
+        try:
+            rv = self.rpc('dumpmnemonic')
+            entropy = Mnemonic('english').to_entropy(rv.split(' '))
+
+            entropy_hash = self.getAddressHashFromKey(entropy)[::-1].hex()
+            self._have_checked_seed = True
+            return entropy_hash == key_hash
+        except Exception as e:
+            self._log.warning('checkExpectedSeed failed: {}'.format(str(e)))
+        return False
+
+    def getScriptForP2PKH(self, pkh: bytes) -> bytearray:
+        # Return P2PKH
+        return CScript([OP_DUP, OP_HASH160, pkh, OP_EQUALVERIFY, OP_CHECKSIG])
+
+    def getScriptForPubkeyHash(self, pkh: bytes) -> bytearray:
+        # Return P2SH-p2wpkh
+
+        script = CScript([OP_0, pkh])
+        script_hash = hash160(script)
+        assert len(script_hash) == 20
+
+        return CScript([OP_HASH160, script_hash, OP_EQUAL])
+
+    def getInputScriptForPubkeyHash(self, pkh: bytes) -> bytearray:
+        script = CScript([OP_0, pkh])
+        return bytes((len(script),)) + script
+
+    def encodeSegwitAddress(self, pkh: bytes) -> str:
+        # P2SH-p2wpkh
+        script = CScript([OP_0, pkh])
+        script_hash = hash160(script)
+        assert len(script_hash) == 20
+        return encodeAddress(bytes((self.chainparams_network()['script_address'],)) + script_hash)
+
+    def encodeSegwitAddressScript(self, script: bytes) -> str:
+        if len(script) == 23 and script[0] == OP_HASH160 and script[1] == 20 and script[22] == OP_EQUAL:
+            script_hash = script[2:22]
+            return encodeAddress(bytes((self.chainparams_network()['script_address'],)) + script_hash)
+        raise ValueError('Unknown Script')
+
+    def loadTx(self, tx_bytes: bytes) -> CTransaction:
+        # Load tx from bytes to internal representation
+        tx = CTransaction()
+        tx.deserialize(BytesIO(tx_bytes))
+        return tx
+
+    def signTx(self, key_bytes: bytes, tx_bytes: bytes, input_n: int, prevout_script, prevout_value: int):
+        tx = self.loadTx(tx_bytes)
+        sig_hash = SegwitVersion1SignatureHash(prevout_script, tx, input_n, SIGHASH_ALL, prevout_value)
+        eck = PrivateKey(key_bytes)
+        return eck.sign(sig_hash, hasher=None) + bytes((SIGHASH_ALL,))
+
+    def setTxSignature(self, tx_bytes: bytes, stack) -> bytes:
+        tx = self.loadTx(tx_bytes)
+        tx.wit.vtxinwit.clear()
+        tx.wit.vtxinwit.append(CTxInWitness())
+        tx.wit.vtxinwit[0].scriptWitness.stack = stack
+        return tx.serialize_with_witness()
+
+    def getProofOfFunds(self, amount_for, extra_commit_bytes):
+        # TODO: Lock unspent and use same output/s to fund bid
+
+        unspents_by_addr = dict()
+        unspents = self.rpc('listunspent')
+        for u in unspents:
+            if u['spendable'] is not True:
+                continue
+            if u['address'] not in unspents_by_addr:
+                unspents_by_addr[u['address']] = {'total': 0, 'utxos': []}
+            utxo_amount: int = self.make_int(u['amount'], r=1)
+            unspents_by_addr[u['address']]['total'] += utxo_amount
+            unspents_by_addr[u['address']]['utxos'].append((utxo_amount, u['txid'], u['vout']))
+
+        max_utxos: int = 4
+
+        viable_addrs = []
+        for addr, data in unspents_by_addr.items():
+            if data['total'] >= amount_for:
+                # Sort from largest to smallest amount
+                sorted_utxos = sorted(data['utxos'], key=lambda x: x[0])
+
+                # Max outputs required to reach amount_for
+                utxos_req: int = 0
+                sum_value: int = 0
+                for utxo in sorted_utxos:
+                    sum_value += utxo[0]
+                    utxos_req += 1
+                    if sum_value >= amount_for:
+                        break
+
+                if utxos_req <= max_utxos:
+                    viable_addrs.append(addr)
+                    continue
+
+        ensure(len(viable_addrs) > 0, 'Could not find address with enough funds for proof')
+
+        sign_for_addr: str = random.choice(viable_addrs)
+        self._log.debug('sign_for_addr %s', sign_for_addr)
+
+        prove_utxos = []
+        sorted_utxos = sorted(unspents_by_addr[sign_for_addr]['utxos'], key=lambda x: x[0])
+
+        hasher = hashlib.sha256()
+
+        sum_value: int = 0
+        for utxo in sorted_utxos:
+            sum_value += utxo[0]
+            outpoint = (bytes.fromhex(utxo[1]), utxo[2])
+            prove_utxos.append(outpoint)
+            hasher.update(outpoint[0])
+            hasher.update(outpoint[1].to_bytes(2, 'big'))
+            if sum_value >= amount_for:
+                break
+        utxos_hash = hasher.digest()
+
+        self._log.debug('sign_for_addr %s', sign_for_addr)
+
+        if self.using_segwit():  # TODO: Use isSegwitAddress when scantxoutset can use combo
+            # 'Address does not refer to key' for non p2pkh
+            addr_info = self.rpc('validateaddress', [addr, ])
+            if 'isscript' in addr_info and addr_info['isscript'] and 'hex' in addr_info:
+                pkh = bytes.fromhex(addr_info['hex'])[2:]
+                sign_for_addr = self.pkh_to_address(pkh)
+                self._log.debug('sign_for_addr converted %s', sign_for_addr)
+
+        signature = self.rpc('signmessage', [sign_for_addr, sign_for_addr + '_swap_proof_' + utxos_hash.hex() + extra_commit_bytes.hex()])
+
+        return (sign_for_addr, signature, prove_utxos)
+
+    def verifyProofOfFunds(self, address, signature, utxos, extra_commit_bytes):
+        hasher = hashlib.sha256()
+        sum_value: int = 0
+        for outpoint in utxos:
+            hasher.update(outpoint[0])
+            hasher.update(outpoint[1].to_bytes(2, 'big'))
+        utxos_hash = hasher.digest()
+
+        passed = self.verifyMessage(address, address + '_swap_proof_' + utxos_hash.hex() + extra_commit_bytes.hex(), signature)
+        ensure(passed is True, 'Proof of funds signature invalid')
+
+        if self.using_segwit():
+            address = self.encodeSegwitAddress(self.decodeAddress(address)[1:])
+
+        sum_value: int = 0
+        for outpoint in utxos:
+            txout = self.rpc('gettxout', [outpoint[0].hex(), outpoint[1]])
+            sum_value += self.make_int(txout['value'])
+
+        return sum_value
+
+    def createRawFundedTransaction(self, addr_to: str, amount: int, sub_fee: bool = False, lock_unspents: bool = True) -> str:
+        txn = self.rpc('createrawtransaction', [[], {addr_to: self.format_amount(amount)}])
+        fee_rate, fee_src = self.get_fee_rate(self._conf_target)
+        self._log.debug(f'Fee rate: {fee_rate}, source: {fee_src}, block target: {self._conf_target}')
+        if sub_fee:
+            raise ValueError('Navcoin fundrawtransaction is missing the subtractFeeFromOutputs parameter')
+            # options['subtractFeeFromOutputs'] = [0,]
+
+        fee_rate = self.make_int(fee_rate, r=1)
+        return self.fundTx(txn, fee_rate, lock_unspents).hex()
+
+    def isAddressMine(self, address: str, or_watch_only: bool = False) -> bool:
+        addr_info = self.rpc('validateaddress', [address])
+        if not or_watch_only:
+            return addr_info['ismine']
+        return addr_info['ismine'] or addr_info['iswatchonly']
+
+    def createRawSignedTransaction(self, addr_to, amount) -> str:
+        txn_funded = self.createRawFundedTransaction(addr_to, amount)
+        return self.rpc('signrawtransaction', [txn_funded])['hex']
+
+    def getBlockchainInfo(self):
+        rv = self.rpc('getblockchaininfo')
+        synced = round(rv['verificationprogress'], 3)
+        if synced >= 0.997:
+            rv['verificationprogress'] = 1.0
+        return rv
+
+    def encodeScriptDest(self, script_dest: bytes) -> str:
+        script_hash = script_dest[2:-1]  # Extract hash from script
+        return self.sh_to_address(script_hash)
+
+    def encode_p2wsh(self, script: bytes) -> str:
+        return pubkeyToAddress(self.chainparams_network()['script_address'], script)
+
+    def find_prevout_info(self, txn_hex: str, txn_script: bytes):
+        txjs = self.rpc('decoderawtransaction', [txn_hex])
+        n = getVoutByScriptPubKey(txjs, self.getScriptDest(txn_script).hex())
+
+        return {
+            'txid': txjs['txid'],
+            'vout': n,
+            'scriptPubKey': txjs['vout'][n]['scriptPubKey']['hex'],
+            'redeemScript': txn_script.hex(),
+            'amount': txjs['vout'][n]['value']
+        }
+
+    def getNewAddress(self, use_segwit: bool, label: str = 'swap_receive') -> str:
+        address: str = self.rpc('getnewaddress', [label,])
+        if use_segwit:
+            return self.rpc('addwitnessaddress', [address,])
+        return address
+
+    def createRedeemTxn(self, prevout, output_addr: str, output_value: int, txn_script: bytes) -> str:
+        tx = CTransaction()
+        tx.nVersion = self.txVersion()
+        prev_txid = uint256_from_str(bytes.fromhex(prevout['txid'])[::-1])
+
+        tx.vin.append(CTxIn(COutPoint(prev_txid, prevout['vout']),
+                            scriptSig=self.getScriptScriptSig(txn_script)))
+        pkh = self.decodeAddress(output_addr)
+        script = self.getScriptForPubkeyHash(pkh)
+        tx.vout.append(self.txoType()(output_value, script))
+        tx.rehash()
+        return tx.serialize().hex()
+
+    def createRefundTxn(self, prevout, output_addr: str, output_value: int, locktime: int, sequence: int, txn_script: bytes) -> str:
+        tx = CTransaction()
+        tx.nVersion = self.txVersion()
+        tx.nLockTime = locktime
+        prev_txid = uint256_from_str(bytes.fromhex(prevout['txid'])[::-1])
+        tx.vin.append(CTxIn(COutPoint(prev_txid, prevout['vout']),
+                            nSequence=sequence,
+                            scriptSig=self.getScriptScriptSig(txn_script)))
+        pkh = self.decodeAddress(output_addr)
+        script = self.getScriptForPubkeyHash(pkh)
+        tx.vout.append(self.txoType()(output_value, script))
+        tx.rehash()
+        return tx.serialize().hex()
+
+    def getTxSignature(self, tx_hex: str, prevout_data, key_wif: str) -> str:
+        key = decodeWif(key_wif)
+        redeem_script = bytes.fromhex(prevout_data['redeemScript'])
+        sig = self.signTx(key, bytes.fromhex(tx_hex), 0, redeem_script, self.make_int(prevout_data['amount']))
+
+        return sig.hex()
+
+    def verifyTxSig(self, tx_bytes: bytes, sig: bytes, K: bytes, input_n: int, prevout_script: bytes, prevout_value: int) -> bool:
+        tx = self.loadTx(tx_bytes)
+        sig_hash = SegwitVersion1SignatureHash(prevout_script, tx, input_n, SIGHASH_ALL, prevout_value)
+
+        pubkey = PublicKey(K)
+        return pubkey.verify(sig[: -1], sig_hash, hasher=None)  # Pop the hashtype byte
+
+    def verifyRawTransaction(self, tx_hex: str, prevouts):
+        # Only checks signature
+        # verifyrawtransaction
+        self._log.warning('NAV verifyRawTransaction only checks signature')
+        inputs_valid: bool = False
+        validscripts: int = 0
+
+        tx_bytes = bytes.fromhex(tx_hex)
+        tx = self.loadTx(bytes.fromhex(tx_hex))
+
+        signature = tx.wit.vtxinwit[0].scriptWitness.stack[0]
+        pubkey = tx.wit.vtxinwit[0].scriptWitness.stack[1]
+
+        input_n: int = 0
+        prevout_data = prevouts[input_n]
+        redeem_script = bytes.fromhex(prevout_data['redeemScript'])
+        prevout_value = self.make_int(prevout_data['amount'])
+
+        if self.verifyTxSig(tx_bytes, signature, pubkey, input_n, redeem_script, prevout_value):
+            validscripts += 1
+
+        # TODO: validate inputs
+        inputs_valid = True
+
+        return {
+            'inputs_valid': inputs_valid,
+            'validscripts': validscripts,
+        }
+
+    def getHTLCSpendTxVSize(self, redeem: bool = True) -> int:
+        tx_vsize = 5  # Add a few bytes, sequence in script takes variable amount of bytes
+
+        tx_vsize += 184 if redeem else 187
+        return tx_vsize
+
+    def getTxid(self, tx) -> bytes:
+        if isinstance(tx, str):
+            tx = bytes.fromhex(tx)
+        if isinstance(tx, bytes):
+            tx = self.loadTx(tx)
+        tx.rehash()
+        return i2b(tx.sha256)
+
+    def rescanBlockchainForAddress(self, height_start: int, addr_find: str):
+        # Very ugly workaround for missing `rescanblockchain` rpc command
+
+        chain_blocks: int = self.getChainHeight()
+
+        current_height: int = chain_blocks
+        block_hash = self.rpc('getblockhash', [current_height])
+
+        script_hash: bytes = self.decodeAddress(addr_find)
+        find_scriptPubKey = self.getDestForScriptHash(script_hash)
+
+        while current_height > height_start:
+            block_hash = self.rpc('getblockhash', [current_height])
+
+            block = self.rpc('getblock', [block_hash, False])
+            decoded_block = CBlock()
+            decoded_block = FromHex(decoded_block, block)
+            for tx in decoded_block.vtx:
+                for txo in tx.vout:
+                    if txo.scriptPubKey == find_scriptPubKey:
+                        tx.rehash()
+                        txid = i2b(tx.sha256)
+                        self._log.info('Found output to addr: {} in tx {} in block {}'.format(addr_find, txid.hex(), block_hash))
+                        self._log.info('rescanblockchain hack invalidateblock {}'.format(block_hash))
+                        self.rpc('invalidateblock', [block_hash])
+                        self.rpc('reconsiderblock', [block_hash])
+                        return
+            current_height -= 1
+
+    def getLockTxHeight(self, txid, dest_address, bid_amount, rescan_from, find_index: bool = False):
+        # Add watchonly address and rescan if required
+
+        if not self.isAddressMine(dest_address, or_watch_only=True):
+            self.importWatchOnlyAddress(dest_address, 'bid')
+            self._log.info('Imported watch-only addr: {}'.format(dest_address))
+            self._log.info('Rescanning {} chain from height: {}'.format(self.coin_name(), rescan_from))
+            self.rescanBlockchainForAddress(rescan_from, dest_address)
+
+        return_txid = True if txid is None else False
+        if txid is None:
+            txns = self.rpc('listunspent', [0, 9999999, [dest_address, ]])
+
+            for tx in txns:
+                if self.make_int(tx['amount']) == bid_amount:
+                    txid = bytes.fromhex(tx['txid'])
+                    break
+
+        if txid is None:
+            return None
+
+        try:
+            tx = self.rpc('gettransaction', [txid.hex()])
+
+            block_height = 0
+            if 'blockhash' in tx:
+                block_header = self.rpc('getblockheader', [tx['blockhash']])
+                block_height = block_header['height']
+
+            rv = {
+                'depth': 0 if 'confirmations' not in tx else tx['confirmations'],
+                'height': block_height}
+
+        except Exception as e:
+            self._log.debug('getLockTxHeight gettransaction failed: %s, %s', txid.hex(), str(e))
+            return None
+
+        if find_index:
+            tx_obj = self.rpc('decoderawtransaction', [tx['hex']])
+            rv['index'] = find_vout_for_address_from_txobj(tx_obj, dest_address)
+
+        if return_txid:
+            rv['txid'] = txid.hex()
+
+        return rv
+
+    def getBlockWithTxns(self, block_hash):
+        # TODO: Bypass decoderawtransaction and getblockheader
+        block = self.rpc('getblock', [block_hash, False])
+        block_header = self.rpc('getblockheader', [block_hash])
+        decoded_block = CBlock()
+        decoded_block = FromHex(decoded_block, block)
+
+        tx_rv = []
+        for tx in decoded_block.vtx:
+            tx_hex = tx.serialize_with_witness().hex()
+            tx_dec = self.rpc('decoderawtransaction', [tx_hex])
+            if 'hex' not in tx_dec:
+                tx_dec['hex'] = tx_hex
+
+            tx_rv.append(tx_dec)
+
+        block_rv = {
+            'hash': block_hash,
+            'tx': tx_rv,
+            'confirmations': block_header['confirmations'],
+            'height': block_header['height'],
+            'version': block_header['version'],
+            'merkleroot': block_header['merkleroot'],
+        }
+
+        return block_rv
+
+    def getScriptScriptSig(self, script: bytes) -> bytearray:
+        return self.getP2SHP2WSHScriptSig(script)
+
+    def getScriptDest(self, script):
+        return self.getP2SHP2WSHDest(script)
+
+    def getDestForScriptHash(self, script_hash):
+        assert len(script_hash) == 20
+        return CScript([OP_HASH160, script_hash, OP_EQUAL])
+
+    def pubkey_to_segwit_address(self, pk: bytes) -> str:
+        pkh = hash160(pk)
+        script_out = self.getScriptForPubkeyHash(pkh)
+        return self.encodeSegwitAddressScript(script_out)
+
+    def createBLockTx(self, Kbs: bytes, output_amount: int, vkbv=None) -> bytes:
+        tx = CTransaction()
+        tx.nVersion = self.txVersion()
+        script_pk = self.getPkDest(Kbs)
+        tx.vout.append(self.txoType()(output_amount, script_pk))
+        return tx.serialize()
+
+    def spendBLockTx(self, chain_b_lock_txid: bytes, address_to: str, kbv: bytes, kbs: bytes, cb_swap_value: int, b_fee: int, restore_height: int) -> bytes:
+        self._log.info('spendBLockTx %s:\n', chain_b_lock_txid.hex())
+        wtx = self.rpc('gettransaction', [chain_b_lock_txid.hex(), ])
+        lock_tx = self.loadTx(bytes.fromhex(wtx['hex']))
+
+        Kbs = self.getPubkey(kbs)
+        script_pk = self.getPkDest(Kbs)
+        locked_n = findOutput(lock_tx, script_pk)
+        ensure(locked_n is not None, 'Output not found in tx')
+        pkh_to = self.decodeAddress(address_to)
+
+        tx = CTransaction()
+        tx.nVersion = self.txVersion()
+
+        chain_b_lock_txid_int = uint256_from_str(chain_b_lock_txid[::-1])
+
+        script_sig = self.getInputScriptForPubkeyHash(self.getPubkeyHash(Kbs))
+
+        tx.vin.append(CTxIn(COutPoint(chain_b_lock_txid_int, locked_n),
+                            nSequence=0,
+                            scriptSig=script_sig))
+        tx.vout.append(self.txoType()(cb_swap_value, self.getScriptForPubkeyHash(pkh_to)))
+
+        pay_fee = self.getBLockSpendTxFee(tx, b_fee)
+        tx.vout[0].nValue = cb_swap_value - pay_fee
+
+        b_lock_spend_tx = tx.serialize()
+        b_lock_spend_tx = self.signTxWithKey(b_lock_spend_tx, kbs, cb_swap_value)
+
+        return bytes.fromhex(self.publishTx(b_lock_spend_tx))
+
+    def signTxWithKey(self, tx: bytes, key: bytes, prev_amount: int) -> bytes:
+        Key = self.getPubkey(key)
+        pkh = self.getPubkeyHash(Key)
+        script = self.getScriptForP2PKH(pkh)
+
+        sig = self.signTx(key, tx, 0, script, prev_amount)
+
+        stack = [
+            sig,
+            Key,
+        ]
+        return self.setTxSignature(tx, stack)
+
+    def findTxnByHash(self, txid_hex: str):
+        # Only works for wallet txns
+        try:
+            rv = self.rpc('gettransaction', [txid_hex])
+        except Exception as ex:
+            self._log.debug('findTxnByHash getrawtransaction failed: {}'.format(txid_hex))
+            return None
+        if 'confirmations' in rv and rv['confirmations'] >= self.blocks_confirmed:
+            block_height = self.getBlockHeader(rv['blockhash'])['height']
+            return {'txid': txid_hex, 'amount': 0, 'height': block_height}
+        return None
+
+    def createSCLockTx(self, value: int, script: bytearray, vkbv: bytes = None) -> bytes:
+        tx = CTransaction()
+        tx.nVersion = self.txVersion()
+        tx.vout.append(self.txoType()(value, self.getScriptDest(script)))
+
+        return tx.serialize()
+
+    def fundTx(self, tx_hex: str, feerate: int, lock_unspents: bool = True):
+        feerate_str = self.format_amount(feerate)
+        # TODO: unlock unspents if bid cancelled
+        options = {
+            'lockUnspents': lock_unspents,
+            'feeRate': feerate_str,
+        }
+        rv = self.rpc('fundrawtransaction', [tx_hex, options])
+
+        # Sign transaction then strip witness data to fill scriptsig
+        rv = self.rpc('signrawtransaction', [rv['hex']])
+
+        tx_signed = self.loadTx(bytes.fromhex(rv['hex']))
+        if len(tx_signed.vin) != len(tx_signed.wit.vtxinwit):
+            raise ValueError('txn has non segwit input')
+        for witness_data in tx_signed.wit.vtxinwit:
+            if len(witness_data.scriptWitness.stack) < 2:
+                raise ValueError('txn has non segwit input')
+
+        return tx_signed.serialize_without_witness()
+
+    def fundSCLockTx(self, tx_bytes: bytes, feerate, vkbv=None) -> bytes:
+        tx_funded = self.fundTx(tx_bytes.hex(), feerate)
+        return tx_funded
+
+    def createSCLockRefundTx(self, tx_lock_bytes, script_lock, Kal, Kaf, lock1_value, csv_val, tx_fee_rate, vkbv=None):
+        tx_lock = CTransaction()
+        tx_lock = self.loadTx(tx_lock_bytes)
+
+        output_script = self.getScriptDest(script_lock)
+        locked_n = findOutput(tx_lock, output_script)
+        ensure(locked_n is not None, 'Output not found in tx')
+        locked_coin = tx_lock.vout[locked_n].nValue
+
+        tx_lock.rehash()
+        tx_lock_id_int = tx_lock.sha256
+
+        refund_script = self.genScriptLockRefundTxScript(Kal, Kaf, csv_val)
+        tx = CTransaction()
+        tx.nVersion = self.txVersion()
+        tx.vin.append(CTxIn(COutPoint(tx_lock_id_int, locked_n),
+                            nSequence=lock1_value,
+                            scriptSig=self.getScriptScriptSig(script_lock)))
+        tx.vout.append(self.txoType()(locked_coin, self.getScriptDest(refund_script)))
+
+        dummy_witness_stack = self.getScriptLockTxDummyWitness(script_lock)
+        witness_bytes = self.getWitnessStackSerialisedLength(dummy_witness_stack)
+        vsize = self.getTxVSize(tx, add_witness_bytes=witness_bytes)
+        pay_fee = round(tx_fee_rate * vsize / 1000)
+        tx.vout[0].nValue = locked_coin - pay_fee
+
+        tx.rehash()
+        self._log.info('createSCLockRefundTx %s:\n    fee_rate, vsize, fee: %ld, %ld, %ld.',
+                       i2h(tx.sha256), tx_fee_rate, vsize, pay_fee)
+
+        return tx.serialize(), refund_script, tx.vout[0].nValue
+
+    def createSCLockRefundSpendTx(self, tx_lock_refund_bytes, script_lock_refund, pkh_refund_to, tx_fee_rate, vkbv=None):
+        # Returns the coinA locked coin to the leader
+        # The follower will sign the multisig path with a signature encumbered by the leader's coinB spend pubkey
+        # If the leader publishes the decrypted signature the leader's coinB spend privatekey will be revealed to the follower
+
+        tx_lock_refund = self.loadTx(tx_lock_refund_bytes)
+
+        output_script = self.getScriptDest(script_lock_refund)
+        locked_n = findOutput(tx_lock_refund, output_script)
+        ensure(locked_n is not None, 'Output not found in tx')
+        locked_coin = tx_lock_refund.vout[locked_n].nValue
+
+        tx_lock_refund.rehash()
+        tx_lock_refund_hash_int = tx_lock_refund.sha256
+
+        tx = CTransaction()
+        tx.nVersion = self.txVersion()
+        tx.vin.append(CTxIn(COutPoint(tx_lock_refund_hash_int, locked_n),
+                            nSequence=0,
+                            scriptSig=self.getScriptScriptSig(script_lock_refund)))
+
+        tx.vout.append(self.txoType()(locked_coin, self.getScriptForPubkeyHash(pkh_refund_to)))
+
+        dummy_witness_stack = self.getScriptLockRefundSpendTxDummyWitness(script_lock_refund)
+        witness_bytes = self.getWitnessStackSerialisedLength(dummy_witness_stack)
+        vsize = self.getTxVSize(tx, add_witness_bytes=witness_bytes)
+        pay_fee = round(tx_fee_rate * vsize / 1000)
+        tx.vout[0].nValue = locked_coin - pay_fee
+
+        tx.rehash()
+        self._log.info('createSCLockRefundSpendTx %s:\n    fee_rate, vsize, fee: %ld, %ld, %ld.',
+                       i2h(tx.sha256), tx_fee_rate, vsize, pay_fee)
+
+        return tx.serialize()
+
+    def createSCLockRefundSpendToFTx(self, tx_lock_refund_bytes, script_lock_refund, pkh_dest, tx_fee_rate, vkbv=None):
+        # lock refund swipe tx
+        # Sends the coinA locked coin to the follower
+
+        tx_lock_refund = self.loadTx(tx_lock_refund_bytes)
+
+        output_script = self.getScriptDest(script_lock_refund)
+        locked_n = findOutput(tx_lock_refund, output_script)
+        ensure(locked_n is not None, 'Output not found in tx')
+        locked_coin = tx_lock_refund.vout[locked_n].nValue
+
+        A, B, lock2_value, C = self.extractScriptLockRefundScriptValues(script_lock_refund)
+
+        tx_lock_refund.rehash()
+        tx_lock_refund_hash_int = tx_lock_refund.sha256
+
+        tx = CTransaction()
+        tx.nVersion = self.txVersion()
+        tx.vin.append(CTxIn(COutPoint(tx_lock_refund_hash_int, locked_n),
+                            nSequence=lock2_value,
+                            scriptSig=self.getScriptScriptSig(script_lock_refund)))
+
+        tx.vout.append(self.txoType()(locked_coin, self.getScriptForPubkeyHash(pkh_dest)))
+
+        dummy_witness_stack = self.getScriptLockRefundSwipeTxDummyWitness(script_lock_refund)
+        witness_bytes = self.getWitnessStackSerialisedLength(dummy_witness_stack)
+        vsize = self.getTxVSize(tx, add_witness_bytes=witness_bytes)
+        pay_fee = round(tx_fee_rate * vsize / 1000)
+        tx.vout[0].nValue = locked_coin - pay_fee
+
+        tx.rehash()
+        self._log.info('createSCLockRefundSpendToFTx %s:\n    fee_rate, vsize, fee: %ld, %ld, %ld.',
+                       i2h(tx.sha256), tx_fee_rate, vsize, pay_fee)
+
+        return tx.serialize()
+
+    def createSCLockSpendTx(self, tx_lock_bytes, script_lock, pkh_dest, tx_fee_rate, vkbv=None, fee_info={}):
+        tx_lock = self.loadTx(tx_lock_bytes)
+        output_script = self.getScriptDest(script_lock)
+        locked_n = findOutput(tx_lock, output_script)
+        ensure(locked_n is not None, 'Output not found in tx')
+        locked_coin = tx_lock.vout[locked_n].nValue
+
+        tx_lock.rehash()
+        tx_lock_id_int = tx_lock.sha256
+
+        tx = CTransaction()
+        tx.nVersion = self.txVersion()
+        tx.vin.append(CTxIn(COutPoint(tx_lock_id_int, locked_n),
+                            scriptSig=self.getScriptScriptSig(script_lock)))
+
+        tx.vout.append(self.txoType()(locked_coin, self.getScriptForPubkeyHash(pkh_dest)))
+
+        dummy_witness_stack = self.getScriptLockTxDummyWitness(script_lock)
+        witness_bytes = self.getWitnessStackSerialisedLength(dummy_witness_stack)
+        vsize = self.getTxVSize(tx, add_witness_bytes=witness_bytes)
+        pay_fee = round(tx_fee_rate * vsize / 1000)
+        tx.vout[0].nValue = locked_coin - pay_fee
+
+        fee_info['fee_paid'] = pay_fee
+        fee_info['rate_used'] = tx_fee_rate
+        fee_info['witness_bytes'] = witness_bytes
+        fee_info['vsize'] = vsize
+
+        tx.rehash()
+        self._log.info('createSCLockSpendTx %s:\n    fee_rate, vsize, fee: %ld, %ld, %ld.',
+                       i2h(tx.sha256), tx_fee_rate, vsize, pay_fee)
+
+        return tx.serialize()

basicswap/interface/nmc.py

@@ -0,0 +1,42 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+# Copyright (c) 2020-2022 tecnovert
+# Distributed under the MIT software license, see the accompanying
+# file LICENSE or http://www.opensource.org/licenses/mit-license.php.
+
+from .btc import BTCInterface
+from basicswap.chainparams import Coins
+from basicswap.util import (
+    make_int,
+)
+
+
+class NMCInterface(BTCInterface):
+    @staticmethod
+    def coin_type():
+        return Coins.NMC
+
+    def getLockTxHeight(self, txid, dest_address, bid_amount, rescan_from, find_index=False):
+        self._log.debug('[rm] scantxoutset start')  # scantxoutset is slow
+        ro = self.rpc('scantxoutset', ['start', ['addr({})'.format(dest_address)]])  # TODO: Use combo(address) where possible
+        self._log.debug('[rm] scantxoutset end')
+        return_txid = True if txid is None else False
+        for o in ro['unspents']:
+            if txid and o['txid'] != txid.hex():
+                continue
+            # Verify amount
+            if make_int(o['amount']) != int(bid_amount):
+                self._log.warning('Found output to lock tx address of incorrect value: %s, %s', str(o['amount']), o['txid'])
+                continue
+
+            rv = {
+                'depth': 0,
+                'height': o['height']}
+            if o['height'] > 0:
+                rv['depth'] = ro['height'] - o['height']
+            if find_index:
+                rv['index'] = o['vout']
+            if return_txid:
+                rv['txid'] = o['txid']
+            return rv

basicswap/interface/part.py

@@ -1,34 +1,36 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
 
-# Copyright (c) 2020-2021 tecnovert
+# Copyright (c) 2020-2024 tecnovert
 # Distributed under the MIT software license, see the accompanying
 # file LICENSE or http://www.opensource.org/licenses/mit-license.php.
 
 import hashlib
 from enum import IntEnum
 
-from .contrib.test_framework.messages import (
+from basicswap.contrib.test_framework.messages import (
     CTxOutPart,
 )
-from .contrib.test_framework.script import (
+from basicswap.contrib.test_framework.script import (
     CScript,
     OP_0,
     OP_DUP, OP_HASH160, OP_EQUALVERIFY, OP_CHECKSIG
 )
-from .ecc_util import i2b
-
-from .util import (
-    toWIF,
+from basicswap.util import (
     ensure,
     make_int,
-    getP2WSH,
     TemporaryError,
+)
+from basicswap.util.script import (
+    getP2WSH,
     getCompactSizeLen,
-    encodeStealthAddress,
-    getWitnessElementLen)
-from .chainparams import Coins, chainparams
-from .interface_btc import BTCInterface
+    getWitnessElementLen,
+)
+from basicswap.util.address import (
+    toWIF,
+    encodeStealthAddress)
+from basicswap.chainparams import Coins, chainparams
+from .btc import BTCInterface
 
 
 class BalanceTypes(IntEnum):
@@ -40,6 +42,8 @@ class BalanceTypes(IntEnum):
 class PARTInterface(BTCInterface):
     @staticmethod
     def coin_type():
+        # Returns the base coin type
+        # ANON and BLIND PART will return Coins.PART
         return Coins.PART
 
     @staticmethod
@@ -55,30 +59,38 @@ class PARTInterface(BTCInterface):
         return 0xa0
 
     @staticmethod
-    def xmr_swap_alock_spend_tx_vsize() -> int:
-        return 213
+    def xmr_swap_a_lock_spend_tx_vsize() -> int:
+        return 200
+
+    @staticmethod
+    def xmr_swap_b_lock_spend_tx_vsize() -> int:
+        return 138
 
     @staticmethod
     def txoType():
         return CTxOutPart
 
-    def setDefaults(self) -> None:
-        super().setDefaults()
-        self._anon_tx_ring_size = 8  # TODO: Make option
+    def __init__(self, coin_settings, network, swap_client=None):
+        super().__init__(coin_settings, network, swap_client)
+        self.setAnonTxRingSize(int(coin_settings.get('anon_tx_ring_size', 12)))
+
+    def setAnonTxRingSize(self, value):
+        ensure(value >= 3 and value < 33, 'Invalid anon_tx_ring_size value')
+        self._anon_tx_ring_size = value
 
     def knownWalletSeed(self):
         # TODO: Double check
         return True
 
-    def getNewAddress(self, use_segwit):
-        return self.rpc_callback('getnewaddress', ['swap_receive'])
+    def getNewAddress(self, use_segwit, label='swap_receive') -> str:
+        return self.rpc_wallet('getnewaddress', [label])
 
-    def getNewStealthAddress(self):
-        return self.rpc_callback('getnewstealthaddress', ['swap_stealth'])
+    def getNewStealthAddress(self, label='swap_stealth') -> str:
+        return self.rpc_wallet('getnewstealthaddress', [label])
 
     def haveSpentIndex(self):
         version = self.getDaemonVersion()
-        index_info = self.rpc_callback('getinsightinfo' if int(str(version)[:2]) > 19 else 'getindexinfo')
+        index_info = self.rpc('getinsightinfo' if int(str(version)[:2]) > 19 else 'getindexinfo')
         return index_info['spentindex']
 
     def initialiseWallet(self, key):
@@ -86,33 +98,33 @@ class PARTInterface(BTCInterface):
 
     def withdrawCoin(self, value, addr_to, subfee):
         params = [addr_to, value, '', '', subfee, '', True, self._conf_target]
-        return self.rpc_callback('sendtoaddress', params)
+        return self.rpc_wallet('sendtoaddress', params)
 
     def sendTypeTo(self, type_from, type_to, value, addr_to, subfee):
         params = [type_from, type_to,
                   [{'address': addr_to, 'amount': value, 'subfee': subfee}, ],
                   '', '', self._anon_tx_ring_size, 1, False,
                   {'conf_target': self._conf_target}]
-        return self.rpc_callback('sendtypeto', params)
+        return self.rpc_wallet('sendtypeto', params)
 
-    def getScriptForPubkeyHash(self, pkh):
+    def getScriptForPubkeyHash(self, pkh: bytes) -> CScript:
         return CScript([OP_DUP, OP_HASH160, pkh, OP_EQUALVERIFY, OP_CHECKSIG])
 
-    def formatStealthAddress(self, scan_pubkey, spend_pubkey):
+    def formatStealthAddress(self, scan_pubkey, spend_pubkey) -> str:
         prefix_byte = chainparams[self.coin_type()][self._network]['stealth_key_prefix']
 
         return encodeStealthAddress(prefix_byte, scan_pubkey, spend_pubkey)
 
-    def getWitnessStackSerialisedLength(self, witness_stack):
-        length = getCompactSizeLen(len(witness_stack))
+    def getWitnessStackSerialisedLength(self, witness_stack) -> int:
+        length: int = getCompactSizeLen(len(witness_stack))
         for e in witness_stack:
-            length += getWitnessElementLen(len(e) // 2)  # hex -> bytes
+            length += getWitnessElementLen(len(e))
         return length
 
-    def getWalletRestoreHeight(self):
-        start_time = self.rpc_callback('getwalletinfo')['keypoololdest']
+    def getWalletRestoreHeight(self) -> int:
+        start_time = self.rpc_wallet('getwalletinfo')['keypoololdest']
 
-        blockchaininfo = self.rpc_callback('getblockchaininfo')
+        blockchaininfo = self.getBlockchainInfo()
         best_block = blockchaininfo['bestblockhash']
 
         chain_synced = round(blockchaininfo['verificationprogress'], 3)
@@ -120,17 +132,41 @@ class PARTInterface(BTCInterface):
             raise ValueError('{} chain isn\'t synced.'.format(self.coin_name()))
 
         self._log.debug('Finding block at time: {}'.format(start_time))
-        block_hash = self.rpc_callback('getblockhashafter', [start_time])
-        block_header = self.rpc_callback('getblockheader', [block_hash])
+        block_hash = self.rpc('getblockhashafter', [start_time])
+        block_header = self.rpc('getblockheader', [block_hash])
         return block_header['height']
 
+    def getHTLCSpendTxVSize(self, redeem: bool = True) -> int:
+        tx_vsize = 5  # Add a few bytes, sequence in script takes variable amount of bytes
+        tx_vsize += 204 if redeem else 187
+        return tx_vsize
+
+    def getUnspentsByAddr(self):
+        unspent_addr = dict()
+        unspent = self.rpc_wallet('listunspent')
+        for u in unspent:
+            if u['spendable'] is not True:
+                continue
+            if 'address' not in u:
+                continue
+            unspent_addr[u['address']] = unspent_addr.get(u['address'], 0) + self.make_int(u['amount'], r=1)
+        return unspent_addr
+
 
 class PARTInterfaceBlind(PARTInterface):
     @staticmethod
     def balance_type():
         return BalanceTypes.BLIND
 
-    def coin_name(self):
+    @staticmethod
+    def xmr_swap_a_lock_spend_tx_vsize() -> int:
+        return 1032
+
+    @staticmethod
+    def xmr_swap_b_lock_spend_tx_vsize() -> int:
+        return 980
+
+    def coin_name(self) -> str:
         return super().coin_name() + ' Blind'
 
     def getScriptLockTxNonce(self, data):
@@ -146,48 +182,47 @@ class PARTInterfaceBlind(PARTInterface):
             if txo['type'] != 'blind':
                 continue
             try:
-                blinded_info = self.rpc_callback('rewindrangeproof', [txo['rangeproof'], txo['valueCommitment'], nonce.hex()])
+                blinded_info = self.rpc('rewindrangeproof', [txo['rangeproof'], txo['valueCommitment'], nonce.hex()])
                 output_n = txo['n']
 
-                self.rpc_callback('rewindrangeproof', [txo['rangeproof'], txo['valueCommitment'], nonce.hex()])
+                self.rpc('rewindrangeproof', [txo['rangeproof'], txo['valueCommitment'], nonce.hex()])
                 break
             except Exception as e:
                 self._log.debug('Searching for locked output: {}'.format(str(e)))
                 continue
             # Should not be possible for commitment not to match
-            v = self.rpc_callback('verifycommitment', [txo['valueCommitment'], blinded_info['blind'], blinded_info['amount']])
+            v = self.rpc('verifycommitment', [txo['valueCommitment'], blinded_info['blind'], blinded_info['amount']])
             ensure(v['result'] is True, 'verifycommitment failed')
         return output_n, blinded_info
 
-    def createScriptLockTx(self, value, Kal, Kaf, vkbv):
-        script = self.genScriptLockTxScript(Kal, Kaf)
+    def createSCLockTx(self, value: int, script: bytearray, vkbv: bytes) -> bytes:
 
         # Nonce is derived from vkbv, ephemeral_key isn't used
-        ephemeral_key = i2b(self.getNewSecretKey())
+        ephemeral_key = self.getNewSecretKey()
         ephemeral_pubkey = self.getPubkey(ephemeral_key)
-        assert(len(ephemeral_pubkey) == 33)
+        assert (len(ephemeral_pubkey) == 33)
         nonce = self.getScriptLockTxNonce(vkbv)
         p2wsh_addr = self.encode_p2wsh(getP2WSH(script))
         inputs = []
         outputs = [{'type': 'blind', 'amount': self.format_amount(value), 'address': p2wsh_addr, 'nonce': nonce.hex(), 'data': ephemeral_pubkey.hex()}]
         params = [inputs, outputs]
-        rv = self.rpc_callback('createrawparttransaction', params)
+        rv = self.rpc_wallet('createrawparttransaction', params)
 
         tx_bytes = bytes.fromhex(rv['hex'])
-        return tx_bytes, script
+        return tx_bytes
 
-    def fundScriptLockTx(self, tx_bytes, feerate, vkbv):
+    def fundSCLockTx(self, tx_bytes: bytes, feerate: int, vkbv: bytes) -> bytes:
         feerate_str = self.format_amount(feerate)
         # TODO: unlock unspents if bid cancelled
 
         tx_hex = tx_bytes.hex()
         nonce = self.getScriptLockTxNonce(vkbv)
 
-        tx_obj = self.rpc_callback('decoderawtransaction', [tx_hex])
+        tx_obj = self.rpc('decoderawtransaction', [tx_hex])
 
-        assert(len(tx_obj['vout']) == 1)
+        assert (len(tx_obj['vout']) == 1)
         txo = tx_obj['vout'][0]
-        blinded_info = self.rpc_callback('rewindrangeproof', [txo['rangeproof'], txo['valueCommitment'], nonce.hex()])
+        blinded_info = self.rpc('rewindrangeproof', [txo['rangeproof'], txo['valueCommitment'], nonce.hex()])
 
         outputs_info = {0: {'value': blinded_info['amount'], 'blind': blinded_info['blind'], 'nonce': nonce.hex()}}
 
@@ -195,16 +230,16 @@ class PARTInterfaceBlind(PARTInterface):
             'lockUnspents': True,
             'feeRate': feerate_str,
         }
-        rv = self.rpc_callback('fundrawtransactionfrom', ['blind', tx_hex, {}, outputs_info, options])
+        rv = self.rpc('fundrawtransactionfrom', ['blind', tx_hex, {}, outputs_info, options])
         return bytes.fromhex(rv['hex'])
 
-    def createScriptLockRefundTx(self, tx_lock_bytes, script_lock, Kal, Kaf, lock1_value, csv_val, tx_fee_rate, vkbv):
-        lock_tx_obj = self.rpc_callback('decoderawtransaction', [tx_lock_bytes.hex()])
-        assert(self.getTxid(tx_lock_bytes).hex() == lock_tx_obj['txid'])
+    def createSCLockRefundTx(self, tx_lock_bytes, script_lock, Kal, Kaf, lock1_value, csv_val, tx_fee_rate, vkbv):
+        lock_tx_obj = self.rpc('decoderawtransaction', [tx_lock_bytes.hex()])
+        assert (self.getTxid(tx_lock_bytes).hex() == lock_tx_obj['txid'])
         # Nonce is derived from vkbv, ephemeral_key isn't used
-        ephemeral_key = i2b(self.getNewSecretKey())
+        ephemeral_key = self.getNewSecretKey()
         ephemeral_pubkey = self.getPubkey(ephemeral_key)
-        assert(len(ephemeral_pubkey) == 33)
+        assert (len(ephemeral_pubkey) == 33)
         nonce = self.getScriptLockTxNonce(vkbv)
         output_nonce = self.getScriptLockRefundTxNonce(vkbv)
 
@@ -220,14 +255,15 @@ class PARTInterfaceBlind(PARTInterface):
         inputs = [{'txid': tx_lock_id, 'vout': spend_n, 'sequence': lock1_value, 'blindingfactor': input_blinded_info['blind']}]
         outputs = [{'type': 'blind', 'amount': locked_coin, 'address': p2wsh_addr, 'nonce': output_nonce.hex(), 'data': ephemeral_pubkey.hex()}]
         params = [inputs, outputs]
-        rv = self.rpc_callback('createrawparttransaction', params)
+        rv = self.rpc_wallet('createrawparttransaction', params)
         lock_refund_tx_hex = rv['hex']
 
         # Set dummy witness data for fee estimation
         dummy_witness_stack = self.getScriptLockTxDummyWitness(script_lock)
+        dummy_witness_stack = [x.hex() for x in dummy_witness_stack]
 
         # Use a junk change pubkey to avoid adding unused keys to the wallet
-        zero_change_key = i2b(self.getNewSecretKey())
+        zero_change_key = self.getNewSecretKey()
         zero_change_pubkey = self.getPubkey(zero_change_key)
         inputs_info = {'0': {'value': input_blinded_info['amount'], 'blind': input_blinded_info['blind'], 'witnessstack': dummy_witness_stack}}
         outputs_info = rv['amounts']
@@ -236,7 +272,7 @@ class PARTInterfaceBlind(PARTInterface):
             'feeRate': self.format_amount(tx_fee_rate),
             'subtractFeeFromOutputs': [0, ]
         }
-        rv = self.rpc_callback('fundrawtransactionfrom', ['blind', lock_refund_tx_hex, inputs_info, outputs_info, options])
+        rv = self.rpc_wallet('fundrawtransactionfrom', ['blind', lock_refund_tx_hex, inputs_info, outputs_info, options])
         lock_refund_tx_hex = rv['hex']
 
         for vout, txo in rv['output_amounts'].items():
@@ -245,12 +281,12 @@ class PARTInterfaceBlind(PARTInterface):
 
         return bytes.fromhex(lock_refund_tx_hex), refund_script, refunded_value
 
-    def createScriptLockRefundSpendTx(self, tx_lock_refund_bytes, script_lock_refund, pkh_refund_to, tx_fee_rate, vkbv):
+    def createSCLockRefundSpendTx(self, tx_lock_refund_bytes, script_lock_refund, pkh_refund_to, tx_fee_rate, vkbv):
         # Returns the coinA locked coin to the leader
         # The follower will sign the multisig path with a signature encumbered by the leader's coinB spend pubkey
         # If the leader publishes the decrypted signature the leader's coinB spend privatekey will be revealed to the follower
 
-        lock_refund_tx_obj = self.rpc_callback('decoderawtransaction', [tx_lock_refund_bytes.hex()])
+        lock_refund_tx_obj = self.rpc('decoderawtransaction', [tx_lock_refund_bytes.hex()])
         # Nonce is derived from vkbv
         nonce = self.getScriptLockRefundTxNonce(vkbv)
 
@@ -260,7 +296,7 @@ class PARTInterfaceBlind(PARTInterface):
 
         tx_lock_refund_id = lock_refund_tx_obj['txid']
         addr_out = self.pkh_to_address(pkh_refund_to)
-        addr_info = self.rpc_callback('getaddressinfo', [addr_out])
+        addr_info = self.rpc_wallet('getaddressinfo', [addr_out])
         output_pubkey_hex = addr_info['pubkey']
 
         # Follower won't be able to decode output to check amount, shouldn't matter as fee is public and output is to leader, sum has to balance
@@ -268,14 +304,15 @@ class PARTInterfaceBlind(PARTInterface):
         inputs = [{'txid': tx_lock_refund_id, 'vout': spend_n, 'sequence': 0, 'blindingfactor': input_blinded_info['blind']}]
         outputs = [{'type': 'blind', 'amount': input_blinded_info['amount'], 'address': addr_out, 'pubkey': output_pubkey_hex}]
         params = [inputs, outputs]
-        rv = self.rpc_callback('createrawparttransaction', params)
+        rv = self.rpc_wallet('createrawparttransaction', params)
         lock_refund_spend_tx_hex = rv['hex']
 
         # Set dummy witness data for fee estimation
         dummy_witness_stack = self.getScriptLockRefundSpendTxDummyWitness(script_lock_refund)
+        dummy_witness_stack = [x.hex() for x in dummy_witness_stack]
 
         # Use a junk change pubkey to avoid adding unused keys to the wallet
-        zero_change_key = i2b(self.getNewSecretKey())
+        zero_change_key = self.getNewSecretKey()
         zero_change_pubkey = self.getPubkey(zero_change_key)
         inputs_info = {'0': {'value': input_blinded_info['amount'], 'blind': input_blinded_info['blind'], 'witnessstack': dummy_witness_stack}}
         outputs_info = rv['amounts']
@@ -285,17 +322,17 @@ class PARTInterfaceBlind(PARTInterface):
             'subtractFeeFromOutputs': [0, ]
         }
 
-        rv = self.rpc_callback('fundrawtransactionfrom', ['blind', lock_refund_spend_tx_hex, inputs_info, outputs_info, options])
+        rv = self.rpc_wallet('fundrawtransactionfrom', ['blind', lock_refund_spend_tx_hex, inputs_info, outputs_info, options])
         lock_refund_spend_tx_hex = rv['hex']
 
         return bytes.fromhex(lock_refund_spend_tx_hex)
 
-    def verifyLockTx(self, tx_bytes, script_out,
-                     swap_value,
-                     Kal, Kaf,
-                     feerate,
-                     check_lock_tx_inputs, vkbv):
-        lock_tx_obj = self.rpc_callback('decoderawtransaction', [tx_bytes.hex()])
+    def verifySCLockTx(self, tx_bytes, script_out,
+                       swap_value,
+                       Kal, Kaf,
+                       feerate,
+                       check_lock_tx_inputs, vkbv):
+        lock_tx_obj = self.rpc('decoderawtransaction', [tx_bytes.hex()])
         lock_txid_hex = lock_tx_obj['txid']
         self._log.info('Verifying lock tx: {}.'.format(lock_txid_hex))
 
@@ -334,10 +371,10 @@ class PARTInterfaceBlind(PARTInterface):
 
         return bytes.fromhex(lock_txid_hex), lock_output_n
 
-    def verifyLockRefundTx(self, tx_bytes, lock_tx_bytes, script_out,
-                           prevout_id, prevout_n, prevout_seq, prevout_script,
-                           Kal, Kaf, csv_val_expect, swap_value, feerate, vkbv):
-        lock_refund_tx_obj = self.rpc_callback('decoderawtransaction', [tx_bytes.hex()])
+    def verifySCLockRefundTx(self, tx_bytes, lock_tx_bytes, script_out,
+                             prevout_id, prevout_n, prevout_seq, prevout_script,
+                             Kal, Kaf, csv_val_expect, swap_value, feerate, vkbv):
+        lock_refund_tx_obj = self.rpc('decoderawtransaction', [tx_bytes.hex()])
         lock_refund_txid_hex = lock_refund_tx_obj['txid']
         self._log.info('Verifying lock refund tx: {}.'.format(lock_refund_txid_hex))
 
@@ -370,10 +407,10 @@ class PARTInterfaceBlind(PARTInterface):
         ensure(C == Kaf, 'Bad script pubkey')
 
         # Check rangeproofs and commitments sum
-        lock_tx_obj = self.rpc_callback('decoderawtransaction', [lock_tx_bytes.hex()])
+        lock_tx_obj = self.rpc('decoderawtransaction', [lock_tx_bytes.hex()])
         prevout = lock_tx_obj['vout'][prevout_n]
         prevtxns = [{'txid': prevout_id.hex(), 'vout': prevout_n, 'scriptPubKey': prevout['scriptPubKey']['hex'], 'amount_commitment': prevout['valueCommitment']}]
-        rv = self.rpc_callback('verifyrawtransaction', [tx_bytes.hex(), prevtxns])
+        rv = self.rpc('verifyrawtransaction', [tx_bytes.hex(), prevtxns])
         ensure(rv['outputs_valid'] is True, 'Invalid outputs')
         ensure(rv['inputs_valid'] is True, 'Invalid inputs')
 
@@ -392,11 +429,11 @@ class PARTInterfaceBlind(PARTInterface):
 
         return bytes.fromhex(lock_refund_txid_hex), lock_refund_txo_value, lock_refund_output_n
 
-    def verifyLockRefundSpendTx(self, tx_bytes, lock_refund_tx_bytes,
-                                lock_refund_tx_id, prevout_script,
-                                Kal,
-                                prevout_n, prevout_value, feerate, vkbv):
-        lock_refund_spend_tx_obj = self.rpc_callback('decoderawtransaction', [tx_bytes.hex()])
+    def verifySCLockRefundSpendTx(self, tx_bytes, lock_refund_tx_bytes,
+                                  lock_refund_tx_id, prevout_script,
+                                  Kal,
+                                  prevout_n, prevout_value, feerate, vkbv):
+        lock_refund_spend_tx_obj = self.rpc('decoderawtransaction', [tx_bytes.hex()])
         lock_refund_spend_txid_hex = lock_refund_spend_tx_obj['txid']
         self._log.info('Verifying lock refund spend tx: {}.'.format(lock_refund_spend_txid_hex))
 
@@ -415,10 +452,10 @@ class PARTInterfaceBlind(PARTInterface):
         # Follower is not concerned with them as they pay to leader
 
         # Check rangeproofs and commitments sum
-        lock_refund_tx_obj = self.rpc_callback('decoderawtransaction', [lock_refund_tx_bytes.hex()])
+        lock_refund_tx_obj = self.rpc('decoderawtransaction', [lock_refund_tx_bytes.hex()])
         prevout = lock_refund_tx_obj['vout'][prevout_n]
         prevtxns = [{'txid': lock_refund_tx_id.hex(), 'vout': prevout_n, 'scriptPubKey': prevout['scriptPubKey']['hex'], 'amount_commitment': prevout['valueCommitment']}]
-        rv = self.rpc_callback('verifyrawtransaction', [tx_bytes.hex(), prevtxns])
+        rv = self.rpc('verifyrawtransaction', [tx_bytes.hex(), prevtxns])
         ensure(rv['outputs_valid'] is True, 'Invalid outputs')
         ensure(rv['inputs_valid'] is True, 'Invalid inputs')
 
@@ -433,28 +470,28 @@ class PARTInterfaceBlind(PARTInterface):
         return True
 
     def getLockTxSwapOutputValue(self, bid, xmr_swap):
-        lock_tx_obj = self.rpc_callback('decoderawtransaction', [xmr_swap.a_lock_tx.hex()])
+        lock_tx_obj = self.rpc('decoderawtransaction', [xmr_swap.a_lock_tx.hex()])
         nonce = self.getScriptLockTxNonce(xmr_swap.vkbv)
         output_n, _ = self.findOutputByNonce(lock_tx_obj, nonce)
         ensure(output_n is not None, 'Output not found in tx')
         return bytes.fromhex(lock_tx_obj['vout'][output_n]['valueCommitment'])
 
     def getLockRefundTxSwapOutputValue(self, bid, xmr_swap):
-        lock_refund_tx_obj = self.rpc_callback('decoderawtransaction', [xmr_swap.a_lock_refund_tx.hex()])
+        lock_refund_tx_obj = self.rpc('decoderawtransaction', [xmr_swap.a_lock_refund_tx.hex()])
         nonce = self.getScriptLockRefundTxNonce(xmr_swap.vkbv)
         output_n, _ = self.findOutputByNonce(lock_refund_tx_obj, nonce)
         ensure(output_n is not None, 'Output not found in tx')
         return bytes.fromhex(lock_refund_tx_obj['vout'][output_n]['valueCommitment'])
 
     def getLockRefundTxSwapOutput(self, xmr_swap):
-        lock_refund_tx_obj = self.rpc_callback('decoderawtransaction', [xmr_swap.a_lock_refund_tx.hex()])
+        lock_refund_tx_obj = self.rpc('decoderawtransaction', [xmr_swap.a_lock_refund_tx.hex()])
         nonce = self.getScriptLockRefundTxNonce(xmr_swap.vkbv)
         output_n, _ = self.findOutputByNonce(lock_refund_tx_obj, nonce)
         ensure(output_n is not None, 'Output not found in tx')
         return output_n
 
-    def createScriptLockSpendTx(self, tx_lock_bytes, script_lock, pk_dest, tx_fee_rate, vkbv):
-        lock_tx_obj = self.rpc_callback('decoderawtransaction', [tx_lock_bytes.hex()])
+    def createSCLockSpendTx(self, tx_lock_bytes: bytes, script_lock: bytes, pk_dest: bytes, tx_fee_rate: int, vkbv: bytes, fee_info={}) -> bytes:
+        lock_tx_obj = self.rpc('decoderawtransaction', [tx_lock_bytes.hex()])
         lock_txid_hex = lock_tx_obj['txid']
 
         ensure(lock_tx_obj['version'] == self.txVersion(), 'Bad version')
@@ -470,16 +507,16 @@ class PARTInterfaceBlind(PARTInterface):
         inputs = [{'txid': lock_txid_hex, 'vout': spend_n, 'sequence': 0, 'blindingfactor': blinded_info['blind']}]
         outputs = [{'type': 'blind', 'amount': blinded_info['amount'], 'address': addr_out, 'pubkey': pk_dest.hex()}]
         params = [inputs, outputs]
-        rv = self.rpc_callback('createrawparttransaction', params)
+        rv = self.rpc_wallet('createrawparttransaction', params)
         lock_spend_tx_hex = rv['hex']
 
         # Set dummy witness data for fee estimation
         dummy_witness_stack = self.getScriptLockTxDummyWitness(script_lock)
 
         # Use a junk change pubkey to avoid adding unused keys to the wallet
-        zero_change_key = i2b(self.getNewSecretKey())
+        zero_change_key = self.getNewSecretKey()
         zero_change_pubkey = self.getPubkey(zero_change_key)
-        inputs_info = {'0': {'value': blinded_info['amount'], 'blind': blinded_info['blind'], 'witnessstack': dummy_witness_stack}}
+        inputs_info = {'0': {'value': blinded_info['amount'], 'blind': blinded_info['blind'], 'witnessstack': [x.hex() for x in dummy_witness_stack]}}
         outputs_info = rv['amounts']
         options = {
             'changepubkey': zero_change_pubkey.hex(),
@@ -487,22 +524,29 @@ class PARTInterfaceBlind(PARTInterface):
             'subtractFeeFromOutputs': [0, ]
         }
 
-        rv = self.rpc_callback('fundrawtransactionfrom', ['blind', lock_spend_tx_hex, inputs_info, outputs_info, options])
+        rv = self.rpc_wallet('fundrawtransactionfrom', ['blind', lock_spend_tx_hex, inputs_info, outputs_info, options])
         lock_spend_tx_hex = rv['hex']
-        lock_spend_tx_obj = self.rpc_callback('decoderawtransaction', [lock_spend_tx_hex])
-
-        vsize = lock_spend_tx_obj['vsize']
+        lock_spend_tx_obj = self.rpc('decoderawtransaction', [lock_spend_tx_hex])
         pay_fee = make_int(lock_spend_tx_obj['vout'][0]['ct_fee'])
+
+        # lock_spend_tx_hex does not include the dummy witness stack
+        witness_bytes = self.getWitnessStackSerialisedLength(dummy_witness_stack)
+        vsize = self.getTxVSize(self.loadTx(bytes.fromhex(lock_spend_tx_hex)), add_witness_bytes=witness_bytes)
         actual_tx_fee_rate = pay_fee * 1000 // vsize
-        self._log.info('createScriptLockSpendTx %s:\n    fee_rate, vsize, fee: %ld, %ld, %ld.',
+        self._log.info('createSCLockSpendTx %s:\n    fee_rate, vsize, fee: %ld, %ld, %ld.',
                        lock_spend_tx_obj['txid'], actual_tx_fee_rate, vsize, pay_fee)
 
+        fee_info['vsize'] = vsize
+        fee_info['fee_paid'] = pay_fee
+        fee_info['rate_input'] = tx_fee_rate
+        fee_info['rate_actual'] = actual_tx_fee_rate
+
         return bytes.fromhex(lock_spend_tx_hex)
 
-    def verifyLockSpendTx(self, tx_bytes,
-                          lock_tx_bytes, lock_tx_script,
-                          a_pk_f, feerate, vkbv):
-        lock_spend_tx_obj = self.rpc_callback('decoderawtransaction', [tx_bytes.hex()])
+    def verifySCLockSpendTx(self, tx_bytes,
+                            lock_tx_bytes, lock_tx_script,
+                            a_pk_f, feerate, vkbv):
+        lock_spend_tx_obj = self.rpc('decoderawtransaction', [tx_bytes.hex()])
         lock_spend_txid_hex = lock_spend_tx_obj['txid']
         self._log.info('Verifying lock spend tx: {}.'.format(lock_spend_txid_hex))
 
@@ -510,7 +554,7 @@ class PARTInterfaceBlind(PARTInterface):
         ensure(lock_spend_tx_obj['locktime'] == 0, 'Bad nLockTime')
         ensure(len(lock_spend_tx_obj['vin']) == 1, 'tx doesn\'t have one input')
 
-        lock_tx_obj = self.rpc_callback('decoderawtransaction', [lock_tx_bytes.hex()])
+        lock_tx_obj = self.rpc('decoderawtransaction', [lock_tx_bytes.hex()])
         lock_txid_hex = lock_tx_obj['txid']
 
         # Find the output of the lock tx to verify
@@ -526,7 +570,7 @@ class PARTInterfaceBlind(PARTInterface):
         ensure(len(lock_spend_tx_obj['vout']) == 3, 'tx doesn\'t have three outputs')
 
         addr_out = self.pubkey_to_address(a_pk_f)
-        privkey = self.rpc_callback('dumpprivkey', [addr_out])
+        privkey = self.rpc_wallet('dumpprivkey', [addr_out])
 
         # Find output:
         output_blinded_info = None
@@ -535,7 +579,7 @@ class PARTInterfaceBlind(PARTInterface):
             if txo['type'] != 'blind':
                 continue
             try:
-                output_blinded_info = self.rpc_callback('rewindrangeproof', [txo['rangeproof'], txo['valueCommitment'], privkey, txo['data_hex']])
+                output_blinded_info = self.rpc('rewindrangeproof', [txo['rangeproof'], txo['valueCommitment'], privkey, txo['data_hex']])
                 output_n = txo['n']
                 break
             except Exception as e:
@@ -544,13 +588,13 @@ class PARTInterfaceBlind(PARTInterface):
         ensure(output_n is not None, 'Output not found in tx')
 
         # Commitment
-        v = self.rpc_callback('verifycommitment', [lock_spend_tx_obj['vout'][output_n]['valueCommitment'], output_blinded_info['blind'], output_blinded_info['amount']])
+        v = self.rpc('verifycommitment', [lock_spend_tx_obj['vout'][output_n]['valueCommitment'], output_blinded_info['blind'], output_blinded_info['amount']])
         ensure(v['result'] is True, 'verifycommitment failed')
 
         # Check rangeproofs and commitments sum
         prevout = lock_tx_obj['vout'][spend_n]
         prevtxns = [{'txid': lock_txid_hex, 'vout': spend_n, 'scriptPubKey': prevout['scriptPubKey']['hex'], 'amount_commitment': prevout['valueCommitment']}]
-        rv = self.rpc_callback('verifyrawtransaction', [tx_bytes.hex(), prevtxns])
+        rv = self.rpc('verifyrawtransaction', [tx_bytes.hex(), prevtxns])
         ensure(rv['outputs_valid'] is True, 'Invalid outputs')
         ensure(rv['inputs_valid'] is True, 'Invalid inputs')
 
@@ -571,10 +615,10 @@ class PARTInterfaceBlind(PARTInterface):
 
         return True
 
-    def createScriptLockRefundSpendToFTx(self, tx_lock_refund_bytes, script_lock_refund, pkh_dest, tx_fee_rate, vkbv):
+    def createSCLockRefundSpendToFTx(self, tx_lock_refund_bytes, script_lock_refund, pkh_dest, tx_fee_rate, vkbv):
         # lock refund swipe tx
         # Sends the coinA locked coin to the follower
-        lock_refund_tx_obj = self.rpc_callback('decoderawtransaction', [tx_lock_refund_bytes.hex()])
+        lock_refund_tx_obj = self.rpc('decoderawtransaction', [tx_lock_refund_bytes.hex()])
         nonce = self.getScriptLockRefundTxNonce(vkbv)
 
         # Find the output of the lock refund tx to spend
@@ -583,7 +627,7 @@ class PARTInterfaceBlind(PARTInterface):
 
         tx_lock_refund_id = lock_refund_tx_obj['txid']
         addr_out = self.pkh_to_address(pkh_dest)
-        addr_info = self.rpc_callback('getaddressinfo', [addr_out])
+        addr_info = self.rpc_wallet('getaddressinfo', [addr_out])
         output_pubkey_hex = addr_info['pubkey']
 
         A, B, lock2_value, C = self.extractScriptLockRefundScriptValues(script_lock_refund)
@@ -593,15 +637,16 @@ class PARTInterfaceBlind(PARTInterface):
         inputs = [{'txid': tx_lock_refund_id, 'vout': spend_n, 'sequence': lock2_value, 'blindingfactor': input_blinded_info['blind']}]
         outputs = [{'type': 'blind', 'amount': input_blinded_info['amount'], 'address': addr_out, 'pubkey': output_pubkey_hex}]
         params = [inputs, outputs]
-        rv = self.rpc_callback('createrawparttransaction', params)
+        rv = self.rpc_wallet('createrawparttransaction', params)
 
         lock_refund_swipe_tx_hex = rv['hex']
 
         # Set dummy witness data for fee estimation
         dummy_witness_stack = self.getScriptLockRefundSwipeTxDummyWitness(script_lock_refund)
+        dummy_witness_stack = [x.hex() for x in dummy_witness_stack]
 
         # Use a junk change pubkey to avoid adding unused keys to the wallet
-        zero_change_key = i2b(self.getNewSecretKey())
+        zero_change_key = self.getNewSecretKey()
         zero_change_pubkey = self.getPubkey(zero_change_key)
         inputs_info = {'0': {'value': input_blinded_info['amount'], 'blind': input_blinded_info['blind'], 'witnessstack': dummy_witness_stack}}
         outputs_info = rv['amounts']
@@ -611,13 +656,129 @@ class PARTInterfaceBlind(PARTInterface):
             'subtractFeeFromOutputs': [0, ]
         }
 
-        rv = self.rpc_callback('fundrawtransactionfrom', ['blind', lock_refund_swipe_tx_hex, inputs_info, outputs_info, options])
+        rv = self.rpc_wallet('fundrawtransactionfrom', ['blind', lock_refund_swipe_tx_hex, inputs_info, outputs_info, options])
         lock_refund_swipe_tx_hex = rv['hex']
 
         return bytes.fromhex(lock_refund_swipe_tx_hex)
 
-    def getSpendableBalance(self):
-        return self.make_int(self.rpc_callback('getbalances')['mine']['blind_trusted'])
+    def getSpendableBalance(self) -> int:
+        return self.make_int(self.rpc_wallet('getbalances')['mine']['blind_trusted'])
+
+    def publishBLockTx(self, vkbv: bytes, Kbs: bytes, output_amount: int, feerate: int, delay_for: int = 10, unlock_time: int = 0) -> bytes:
+        Kbv = self.getPubkey(vkbv)
+        sx_addr = self.formatStealthAddress(Kbv, Kbs)
+        self._log.debug('sx_addr: {}'.format(sx_addr))
+
+        # TODO: Fund from other balances
+        params = ['blind', 'blind',
+                  [{'address': sx_addr, 'amount': self.format_amount(output_amount)}, ],
+                  '', '', self._anon_tx_ring_size, 1, False,
+                  {'conf_target': self._conf_target, 'blind_watchonly_visible': True}]
+
+        txid = self.rpc_wallet('sendtypeto', params)
+        return bytes.fromhex(txid)
+
+    def findTxB(self, kbv, Kbs, cb_swap_value, cb_block_confirmed, restore_height: int, bid_sender: bool):
+        Kbv = self.getPubkey(kbv)
+        sx_addr = self.formatStealthAddress(Kbv, Kbs)
+
+        # Tx recipient must import the stealth address as watch only
+        if bid_sender:
+            cb_swap_value *= -1
+        else:
+            addr_info = self.rpc_wallet('getaddressinfo', [sx_addr])
+            if not addr_info['iswatchonly']:
+                wif_prefix = self.chainparams_network()['key_prefix']
+                wif_scan_key = toWIF(wif_prefix, kbv)
+                self.rpc_wallet('importstealthaddress', [wif_scan_key, Kbs.hex()])
+                self._log.info('Imported watch-only sx_addr: {}'.format(sx_addr))
+                self._log.info('Rescanning {} chain from height: {}'.format(self.coin_name(), restore_height))
+                self.rpc_wallet('rescanblockchain', [restore_height])
+
+        params = [{'include_watchonly': True, 'search': sx_addr}]
+        txns = self.rpc_wallet('filtertransactions', params)
+
+        if len(txns) == 1:
+            tx = txns[0]
+            assert (tx['outputs'][0]['stealth_address'] == sx_addr)  # Should not be possible
+            ensure(tx['outputs'][0]['type'] == 'blind', 'Output is not anon')
+
+            if make_int(tx['outputs'][0]['amount']) == cb_swap_value:
+                height = 0
+                if tx['confirmations'] > 0:
+                    chain_height = self.rpc('getblockcount')
+                    height = chain_height - (tx['confirmations'] - 1)
+                return {'txid': tx['txid'], 'amount': cb_swap_value, 'height': height}
+            else:
+                self._log.warning('Incorrect amount detected for coin b lock txn: {}'.format(tx['txid']))
+                return -1
+        return None
+
+    def spendBLockTx(self, chain_b_lock_txid: bytes, address_to: str, kbv: bytes, kbs: bytes, cb_swap_value: int, b_fee: int, restore_height: int, spend_actual_balance: bool = False) -> bytes:
+        Kbv = self.getPubkey(kbv)
+        Kbs = self.getPubkey(kbs)
+        sx_addr = self.formatStealthAddress(Kbv, Kbs)
+        addr_info = self.rpc_wallet('getaddressinfo', [sx_addr])
+        if not addr_info['ismine']:
+            wif_prefix = self.chainparams_network()['key_prefix']
+            wif_scan_key = toWIF(wif_prefix, kbv)
+            wif_spend_key = toWIF(wif_prefix, kbs)
+            self.rpc_wallet('importstealthaddress', [wif_scan_key, wif_spend_key])
+            self._log.info('Imported spend key for sx_addr: {}'.format(sx_addr))
+            self._log.info('Rescanning {} chain from height: {}'.format(self.coin_name(), restore_height))
+            self.rpc_wallet('rescanblockchain', [restore_height])
+
+        # TODO: Remove workaround
+        # utxos = self.rpc_wallet('listunspentblind', [1, 9999999, [sx_addr]])
+        utxos = []
+        all_utxos = self.rpc_wallet('listunspentblind', [1, 9999999])
+        for utxo in all_utxos:
+            if utxo.get('stealth_address', '_') == sx_addr:
+                utxos.append(utxo)
+        if len(utxos) < 1:
+            raise TemporaryError('No spendable outputs')
+        elif len(utxos) > 1:
+            raise ValueError('Too many spendable outputs')
+
+        utxo = utxos[0]
+        utxo_sats = make_int(utxo['amount'])
+
+        if spend_actual_balance and utxo_sats != cb_swap_value:
+            self._log.warning('Spending actual balance {}, not swap value {}.'.format(utxo_sats, cb_swap_value))
+            cb_swap_value = utxo_sats
+
+        inputs = [{'tx': utxo['txid'], 'n': utxo['vout']}, ]
+        params = ['blind', 'blind',
+                  [{'address': address_to, 'amount': self.format_amount(cb_swap_value), 'subfee': True}, ],
+                  '', '', self._anon_tx_ring_size, 1, False,
+                  {'conf_target': self._conf_target, 'inputs': inputs, 'show_fee': True}]
+        rv = self.rpc_wallet('sendtypeto', params)
+        return bytes.fromhex(rv['txid'])
+
+    def findTxnByHash(self, txid_hex):
+        # txindex is enabled for Particl
+
+        try:
+            rv = self.rpc('getrawtransaction', [txid_hex, True])
+        except Exception as ex:
+            self._log.debug('findTxnByHash getrawtransaction failed: {}'.format(txid_hex))
+            return None
+
+        if 'confirmations' in rv and rv['confirmations'] >= self.blocks_confirmed:
+            return {'txid': txid_hex, 'amount': 0, 'height': rv['height']}
+
+        return None
+
+    def createRawFundedTransaction(self, addr_to: str, amount: int, sub_fee: bool = False, lock_unspents: bool = True) -> str:
+        txn = self.rpc_wallet('createrawtransaction', [[], {addr_to: self.format_amount(amount)}])
+
+        options = {
+            'lockUnspents': lock_unspents,
+            'conf_target': self._conf_target,
+        }
+        if sub_fee:
+            options['subtractFeeFromOutputs'] = [0,]
+        return self.rpc_wallet('fundrawtransactionfrom', ['blind', txn, options])['hex']
 
 
 class PARTInterfaceAnon(PARTInterface):
@@ -625,16 +786,25 @@ class PARTInterfaceAnon(PARTInterface):
     def balance_type():
         return BalanceTypes.ANON
 
+    @staticmethod
+    def xmr_swap_a_lock_spend_tx_vsize() -> int:
+        raise ValueError('Not possible')
+
+    @staticmethod
+    def xmr_swap_b_lock_spend_tx_vsize() -> int:
+        # TODO: Estimate with ringsize
+        return 1153
+
     @staticmethod
     def depth_spendable() -> int:
         return 12
 
-    def coin_name(self):
+    def coin_name(self) -> str:
         return super().coin_name() + ' Anon'
 
-    def publishBLockTx(self, Kbv, Kbs, output_amount, feerate):
+    def publishBLockTx(self, kbv: bytes, Kbs: bytes, output_amount: int, feerate: int, delay_for: int = 10, unlock_time: int = 0) -> bytes:
+        Kbv = self.getPubkey(kbv)
         sx_addr = self.formatStealthAddress(Kbv, Kbs)
-        self._log.debug('sx_addr: {}'.format(sx_addr))
 
         # TODO: Fund from other balances
         params = ['anon', 'anon',
@@ -642,7 +812,7 @@ class PARTInterfaceAnon(PARTInterface):
                   '', '', self._anon_tx_ring_size, 1, False,
                   {'conf_target': self._conf_target, 'blind_watchonly_visible': True}]
 
-        txid = self.rpc_callback('sendtypeto', params)
+        txid = self.rpc_wallet('sendtypeto', params)
         return bytes.fromhex(txid)
 
     def findTxB(self, kbv, Kbs, cb_swap_value, cb_block_confirmed, restore_height, bid_sender):
@@ -654,27 +824,27 @@ class PARTInterfaceAnon(PARTInterface):
         if bid_sender:
             cb_swap_value *= -1
         else:
-            addr_info = self.rpc_callback('getaddressinfo', [sx_addr])
+            addr_info = self.rpc_wallet('getaddressinfo', [sx_addr])
             if not addr_info['iswatchonly']:
                 wif_prefix = self.chainparams_network()['key_prefix']
                 wif_scan_key = toWIF(wif_prefix, kbv)
-                self.rpc_callback('importstealthaddress', [wif_scan_key, Kbs.hex()])
+                self.rpc_wallet('importstealthaddress', [wif_scan_key, Kbs.hex()])
                 self._log.info('Imported watch-only sx_addr: {}'.format(sx_addr))
-                self._log.info('Rescanning chain from height: {}'.format(restore_height))
-                self.rpc_callback('rescanblockchain', [restore_height])
+                self._log.info('Rescanning {} chain from height: {}'.format(self.coin_name(), restore_height))
+                self.rpc_wallet('rescanblockchain', [restore_height])
 
         params = [{'include_watchonly': True, 'search': sx_addr}]
-        txns = self.rpc_callback('filtertransactions', params)
+        txns = self.rpc_wallet('filtertransactions', params)
 
         if len(txns) == 1:
             tx = txns[0]
-            assert(tx['outputs'][0]['stealth_address'] == sx_addr)  # Should not be possible
+            assert (tx['outputs'][0]['stealth_address'] == sx_addr)  # Should not be possible
             ensure(tx['outputs'][0]['type'] == 'anon', 'Output is not anon')
 
             if make_int(tx['outputs'][0]['amount']) == cb_swap_value:
                 height = 0
                 if tx['confirmations'] > 0:
-                    chain_height = self.rpc_callback('getblockcount')
+                    chain_height = self.rpc('getblockcount')
                     height = chain_height - (tx['confirmations'] - 1)
                 return {'txid': tx['txid'], 'amount': cb_swap_value, 'height': height}
             else:
@@ -682,21 +852,21 @@ class PARTInterfaceAnon(PARTInterface):
                 return -1
         return None
 
-    def spendBLockTx(self, chain_b_lock_txid, address_to, kbv, kbs, cb_swap_value, b_fee, restore_height, spend_actual_balance=False):
+    def spendBLockTx(self, chain_b_lock_txid: bytes, address_to: str, kbv: bytes, kbs: bytes, cb_swap_value: int, b_fee: int, restore_height: int, spend_actual_balance: bool = False) -> bytes:
         Kbv = self.getPubkey(kbv)
         Kbs = self.getPubkey(kbs)
         sx_addr = self.formatStealthAddress(Kbv, Kbs)
-        addr_info = self.rpc_callback('getaddressinfo', [sx_addr])
+        addr_info = self.rpc_wallet('getaddressinfo', [sx_addr])
         if not addr_info['ismine']:
             wif_prefix = self.chainparams_network()['key_prefix']
             wif_scan_key = toWIF(wif_prefix, kbv)
             wif_spend_key = toWIF(wif_prefix, kbs)
-            self.rpc_callback('importstealthaddress', [wif_scan_key, wif_spend_key])
+            self.rpc_wallet('importstealthaddress', [wif_scan_key, wif_spend_key])
             self._log.info('Imported spend key for sx_addr: {}'.format(sx_addr))
-            self._log.info('Rescanning chain from height: {}'.format(restore_height))
-            self.rpc_callback('rescanblockchain', [restore_height])
+            self._log.info('Rescanning {} chain from height: {}'.format(self.coin_name(), restore_height))
+            self.rpc_wallet('rescanblockchain', [restore_height])
 
-        autxos = self.rpc_callback('listunspentanon', [1, 9999999, [sx_addr]])
+        autxos = self.rpc_wallet('listunspentanon', [1, 9999999, [sx_addr]])
 
         if len(autxos) < 1:
             raise TemporaryError('No spendable outputs')
@@ -705,6 +875,7 @@ class PARTInterfaceAnon(PARTInterface):
 
         utxo = autxos[0]
         utxo_sats = make_int(utxo['amount'])
+
         if spend_actual_balance and utxo_sats != cb_swap_value:
             self._log.warning('Spending actual balance {}, not swap value {}.'.format(utxo_sats, cb_swap_value))
             cb_swap_value = utxo_sats
@@ -714,14 +885,14 @@ class PARTInterfaceAnon(PARTInterface):
                   [{'address': address_to, 'amount': self.format_amount(cb_swap_value), 'subfee': True}, ],
                   '', '', self._anon_tx_ring_size, 1, False,
                   {'conf_target': self._conf_target, 'inputs': inputs, 'show_fee': True}]
-        rv = self.rpc_callback('sendtypeto', params)
+        rv = self.rpc_wallet('sendtypeto', params)
         return bytes.fromhex(rv['txid'])
 
-    def findTxnByHash(self, txid_hex):
+    def findTxnByHash(self, txid_hex: str):
         # txindex is enabled for Particl
 
         try:
-            rv = self.rpc_callback('getrawtransaction', [txid_hex, True])
+            rv = self.rpc('getrawtransaction', [txid_hex, True])
         except Exception as ex:
             self._log.debug('findTxnByHash getrawtransaction failed: {}'.format(txid_hex))
             return None
@@ -731,5 +902,5 @@ class PARTInterfaceAnon(PARTInterface):
 
         return None
 
-    def getSpendableBalance(self):
-        return self.make_int(self.rpc_callback('getbalances')['mine']['anon_trusted'])
+    def getSpendableBalance(self) -> int:
+        return self.make_int(self.rpc_wallet('getbalances')['mine']['anon_trusted'])

basicswap/interface/passthrough_btc.py

@@ -5,8 +5,8 @@
 # Distributed under the MIT software license, see the accompanying
 # file LICENSE or http://www.opensource.org/licenses/mit-license.php.
 
-from .interface_btc import BTCInterface
-from .contrib.test_framework.messages import (
+from .btc import BTCInterface
+from basicswap.contrib.test_framework.messages import (
     CTxOut)
 
 

basicswap/interface/pivx.py

@@ -0,0 +1,126 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+# Copyright (c) 2022 tecnovert
+# Distributed under the MIT software license, see the accompanying
+# file LICENSE or http://www.opensource.org/licenses/mit-license.php.
+
+from io import BytesIO
+
+from .btc import BTCInterface
+from basicswap.rpc import make_rpc_func
+from basicswap.chainparams import Coins
+from basicswap.util.address import decodeAddress
+from .contrib.pivx_test_framework.messages import (
+    CBlock,
+    ToHex,
+    FromHex,
+    CTransaction)
+from basicswap.contrib.test_framework.script import (
+    CScript,
+    OP_DUP,
+    OP_HASH160,
+    OP_CHECKSIG,
+    OP_EQUALVERIFY,
+)
+
+
+class PIVXInterface(BTCInterface):
+    @staticmethod
+    def coin_type():
+        return Coins.PIVX
+
+    def __init__(self, coin_settings, network, swap_client=None):
+        super(PIVXInterface, self).__init__(coin_settings, network, swap_client)
+        # No multiwallet support
+        self.rpc_wallet = make_rpc_func(self._rpcport, self._rpcauth, host=self._rpc_host)
+
+    def checkWallets(self) -> int:
+        return 1
+
+    def signTxWithWallet(self, tx):
+        rv = self.rpc('signrawtransaction', [tx.hex()])
+        return bytes.fromhex(rv['hex'])
+
+    def createRawFundedTransaction(self, addr_to: str, amount: int, sub_fee: bool = False, lock_unspents: bool = True) -> str:
+        txn = self.rpc('createrawtransaction', [[], {addr_to: self.format_amount(amount)}])
+        fee_rate, fee_src = self.get_fee_rate(self._conf_target)
+        self._log.debug(f'Fee rate: {fee_rate}, source: {fee_src}, block target: {self._conf_target}')
+        options = {
+            'lockUnspents': lock_unspents,
+            'feeRate': fee_rate,
+        }
+        if sub_fee:
+            options['subtractFeeFromOutputs'] = [0,]
+        return self.rpc('fundrawtransaction', [txn, options])['hex']
+
+    def createRawSignedTransaction(self, addr_to, amount) -> str:
+        txn_funded = self.createRawFundedTransaction(addr_to, amount)
+        return self.rpc('signrawtransaction', [txn_funded])['hex']
+
+    def decodeAddress(self, address):
+        return decodeAddress(address)[1:]
+
+    def getBlockWithTxns(self, block_hash):
+        # TODO: Bypass decoderawtransaction and getblockheader
+        block = self.rpc('getblock', [block_hash, False])
+        block_header = self.rpc('getblockheader', [block_hash])
+        decoded_block = CBlock()
+        decoded_block = FromHex(decoded_block, block)
+
+        tx_rv = []
+        for tx in decoded_block.vtx:
+            tx_dec = self.rpc('decoderawtransaction', [ToHex(tx)])
+            tx_rv.append(tx_dec)
+
+        block_rv = {
+            'hash': block_hash,
+            'tx': tx_rv,
+            'confirmations': block_header['confirmations'],
+            'height': block_header['height'],
+            'version': block_header['version'],
+            'merkleroot': block_header['merkleroot'],
+        }
+
+        return block_rv
+
+    def withdrawCoin(self, value, addr_to, subfee):
+        params = [addr_to, value, '', '', subfee]
+        return self.rpc('sendtoaddress', params)
+
+    def getSpendableBalance(self) -> int:
+        return self.make_int(self.rpc('getwalletinfo')['balance'])
+
+    def loadTx(self, tx_bytes):
+        # Load tx from bytes to internal representation
+        tx = CTransaction()
+        tx.deserialize(BytesIO(tx_bytes))
+        return tx
+
+    def getScriptForPubkeyHash(self, pkh: bytes) -> bytearray:
+        # Return P2PKH
+        return CScript([OP_DUP, OP_HASH160, pkh, OP_EQUALVERIFY, OP_CHECKSIG])
+
+    def getBLockSpendTxFee(self, tx, fee_rate: int) -> int:
+        add_bytes = 107
+        size = len(tx.serialize_with_witness()) + add_bytes
+        pay_fee = round(fee_rate * size / 1000)
+        self._log.info(f'BLockSpendTx  fee_rate, size, fee: {fee_rate}, {size}, {pay_fee}.')
+        return pay_fee
+
+    def signTxWithKey(self, tx: bytes, key: bytes) -> bytes:
+        key_wif = self.encodeKey(key)
+        rv = self.rpc('signrawtransaction', [tx.hex(), [], [key_wif, ]])
+        return bytes.fromhex(rv['hex'])
+
+    def findTxnByHash(self, txid_hex: str):
+        # Only works for wallet txns
+        try:
+            rv = self.rpc('gettransaction', [txid_hex])
+        except Exception as ex:
+            self._log.debug('findTxnByHash getrawtransaction failed: {}'.format(txid_hex))
+            return None
+        if 'confirmations' in rv and rv['confirmations'] >= self.blocks_confirmed:
+            block_height = self.getBlockHeader(rv['blockhash'])['height']
+            return {'txid': txid_hex, 'amount': 0, 'height': block_height}
+        return None

basicswap/interface/xmr.py

@@ -0,0 +1,573 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+# Copyright (c) 2020-2024 tecnovert
+# Distributed under the MIT software license, see the accompanying
+# file LICENSE or http://www.opensource.org/licenses/mit-license.php.
+
+import json
+import logging
+
+import basicswap.contrib.ed25519_fast as edf
+import basicswap.ed25519_fast_util as edu
+import basicswap.util_xmr as xmr_util
+from coincurve.ed25519 import (
+    ed25519_add,
+    ed25519_get_pubkey,
+    ed25519_scalar_add,
+)
+from coincurve.keys import PrivateKey
+from coincurve.dleag import (
+    dleag_prove,
+    dleag_verify,
+    dleag_proof_len,
+    verify_ed25519_point,
+)
+
+from basicswap.interface import (
+    Curves)
+from basicswap.util import (
+    i2b, b2i, b2h,
+    dumpj,
+    ensure,
+    make_int,
+    TemporaryError)
+from basicswap.util.network import (
+    is_private_ip_address)
+from basicswap.rpc_xmr import (
+    make_xmr_rpc_func,
+    make_xmr_rpc2_func)
+from basicswap.chainparams import XMR_COIN, CoinInterface, Coins
+
+
+class XMRInterface(CoinInterface):
+    @staticmethod
+    def curve_type():
+        return Curves.ed25519
+
+    @staticmethod
+    def coin_type():
+        return Coins.XMR
+
+    @staticmethod
+    def COIN():
+        return XMR_COIN
+
+    @staticmethod
+    def exp() -> int:
+        return 12
+
+    @staticmethod
+    def nbk() -> int:
+        return 32
+
+    @staticmethod
+    def nbK() -> int:  # No. of bytes requires to encode a public key
+        return 32
+
+    @staticmethod
+    def depth_spendable() -> int:
+        return 10
+
+    @staticmethod
+    def xmr_swap_a_lock_spend_tx_vsize() -> int:
+        raise ValueError('Not possible')
+
+    @staticmethod
+    def xmr_swap_b_lock_spend_tx_vsize() -> int:
+        # TODO: Estimate with ringsize
+        return 1507
+
+    def __init__(self, coin_settings, network, swap_client=None):
+        super().__init__(network)
+
+        self.blocks_confirmed = coin_settings['blocks_confirmed']
+        self._restore_height = coin_settings.get('restore_height', 0)
+        self.setFeePriority(coin_settings.get('fee_priority', 0))
+        self._sc = swap_client
+        self._log = self._sc.log if self._sc and self._sc.log else logging
+        self._wallet_password = None
+        self._have_checked_seed = False
+
+        daemon_login = None
+        if coin_settings.get('rpcuser', '') != '':
+            daemon_login = (coin_settings.get('rpcuser', ''), coin_settings.get('rpcpassword', ''))
+
+        rpchost = coin_settings.get('rpchost', '127.0.0.1')
+        proxy_host = None
+        proxy_port = None
+        # Connect to the daemon over a proxy if not running locally
+        if swap_client:
+            chain_client_settings = swap_client.getChainClientSettings(self.coin_type())
+            manage_daemon: bool = chain_client_settings['manage_daemon']
+            if swap_client.use_tor_proxy:
+                if manage_daemon is False:
+                    log_str: str = ''
+                    have_cc_tor_opt = 'use_tor' in chain_client_settings
+                    if have_cc_tor_opt and chain_client_settings['use_tor'] is False:
+                        log_str = ' bypassing proxy (use_tor false for XMR)'
+                    elif have_cc_tor_opt is False and is_private_ip_address(rpchost):
+                        log_str = ' bypassing proxy (private ip address)'
+                    else:
+                        proxy_host = swap_client.tor_proxy_host
+                        proxy_port = swap_client.tor_proxy_port
+                        log_str = f' through proxy at {proxy_host}'
+                    self._log.info(f'Connecting to remote {self.coin_name()} daemon at {rpchost}{log_str}.')
+                else:
+                    self._log.info(f'Not connecting to local {self.coin_name()} daemon through proxy.')
+            elif manage_daemon is False:
+                self._log.info(f'Connecting to remote {self.coin_name()} daemon at {rpchost}.')
+
+        self._rpctimeout = coin_settings.get('rpctimeout', 60)
+        self._walletrpctimeout = coin_settings.get('walletrpctimeout', 120)
+        self._walletrpctimeoutlong = coin_settings.get('walletrpctimeoutlong', 600)
+
+        self.rpc = make_xmr_rpc_func(coin_settings['rpcport'], daemon_login, host=rpchost, proxy_host=proxy_host, proxy_port=proxy_port, default_timeout=self._rpctimeout, tag='Node(j) ')
+        self.rpc2 = make_xmr_rpc2_func(coin_settings['rpcport'], daemon_login, host=rpchost, proxy_host=proxy_host, proxy_port=proxy_port, default_timeout=self._rpctimeout, tag='Node ')  # non-json endpoint
+        self.rpc_wallet = make_xmr_rpc_func(coin_settings['walletrpcport'], coin_settings['walletrpcauth'], host=coin_settings.get('walletrpchost', '127.0.0.1'), default_timeout=self._walletrpctimeout, tag='Wallet ')
+
+    def checkWallets(self) -> int:
+        return 1
+
+    def setFeePriority(self, new_priority):
+        ensure(new_priority >= 0 and new_priority < 4, 'Invalid fee_priority value')
+        self._fee_priority = new_priority
+
+    def setWalletFilename(self, wallet_filename):
+        self._wallet_filename = wallet_filename
+
+    def createWallet(self, params):
+        if self._wallet_password is not None:
+            params['password'] = self._wallet_password
+        rv = self.rpc_wallet('generate_from_keys', params)
+        self._log.info('generate_from_keys %s', dumpj(rv))
+
+    def openWallet(self, filename):
+        params = {'filename': filename}
+        if self._wallet_password is not None:
+            params['password'] = self._wallet_password
+
+        try:
+            # Can't reopen the same wallet in windows, !is_keys_file_locked()
+            self.rpc_wallet('close_wallet')
+        except Exception:
+            pass
+        self.rpc_wallet('open_wallet', params)
+
+    def initialiseWallet(self, key_view, key_spend, restore_height=None):
+        with self._mx_wallet:
+            try:
+                self.openWallet(self._wallet_filename)
+                # TODO: Check address
+                return  # Wallet exists
+            except Exception as e:
+                pass
+
+            Kbv = self.getPubkey(key_view)
+            Kbs = self.getPubkey(key_spend)
+            address_b58 = xmr_util.encode_address(Kbv, Kbs)
+
+            params = {
+                'filename': self._wallet_filename,
+                'address': address_b58,
+                'viewkey': b2h(key_view[::-1]),
+                'spendkey': b2h(key_spend[::-1]),
+                'restore_height': self._restore_height,
+            }
+            self.createWallet(params)
+            self.openWallet(self._wallet_filename)
+
+    def ensureWalletExists(self) -> None:
+        with self._mx_wallet:
+            self.openWallet(self._wallet_filename)
+
+    def testDaemonRPC(self, with_wallet=True) -> None:
+        self.rpc_wallet('get_languages')
+
+    def getDaemonVersion(self):
+        return self.rpc_wallet('get_version')['version']
+
+    def getBlockchainInfo(self):
+        get_height = self.rpc2('get_height', timeout=self._rpctimeout)
+        rv = {
+            'blocks': get_height['height'],
+            'verificationprogress': 0.0,
+        }
+
+        try:
+            # get_block_count.block_count is how many blocks are in the longest chain known to the node.
+            # get_block_count returns "Internal error" if bootstrap-daemon is active
+            if get_height['untrusted'] is True:
+                rv['bootstrapping'] = True
+                get_info = self.rpc2('get_info', timeout=self._rpctimeout)
+                if 'height_without_bootstrap' in get_info:
+                    rv['blocks'] = get_info['height_without_bootstrap']
+
+                rv['known_block_count'] = get_info['height']
+                if rv['known_block_count'] > rv['blocks']:
+                    rv['verificationprogress'] = rv['blocks'] / rv['known_block_count']
+            else:
+                rv['known_block_count'] = self.rpc('get_block_count', timeout=self._rpctimeout)['count']
+                rv['verificationprogress'] = rv['blocks'] / rv['known_block_count']
+        except Exception as e:
+            self._log.warning('XMR get_block_count failed with: %s', str(e))
+            rv['verificationprogress'] = 0.0
+
+        return rv
+
+    def getChainHeight(self):
+        return self.rpc2('get_height', timeout=self._rpctimeout)['height']
+
+    def getWalletInfo(self):
+        with self._mx_wallet:
+            try:
+                self.openWallet(self._wallet_filename)
+            except Exception as e:
+                if 'Failed to open wallet' in str(e):
+                    rv = {'encrypted': True, 'locked': True, 'balance': 0, 'unconfirmed_balance': 0}
+                    return rv
+                raise e
+
+            rv = {}
+            self.rpc_wallet('refresh')
+            balance_info = self.rpc_wallet('get_balance')
+            rv['balance'] = self.format_amount(balance_info['unlocked_balance'])
+            rv['unconfirmed_balance'] = self.format_amount(balance_info['balance'] - balance_info['unlocked_balance'])
+            rv['encrypted'] = False if self._wallet_password is None else True
+            rv['locked'] = False
+            return rv
+
+    def walletRestoreHeight(self):
+        return self._restore_height
+
+    def getMainWalletAddress(self) -> str:
+        with self._mx_wallet:
+            self.openWallet(self._wallet_filename)
+            return self.rpc_wallet('get_address')['address']
+
+    def getNewAddress(self, placeholder) -> str:
+        with self._mx_wallet:
+            self.openWallet(self._wallet_filename)
+            new_address = self.rpc_wallet('create_address', {'account_index': 0})['address']
+            self.rpc_wallet('store')
+            return new_address
+
+    def get_fee_rate(self, conf_target: int = 2):
+        self._log.warning('TODO - estimate XMR fee rate?')
+        return 0.0, 'unused'
+
+    def getNewSecretKey(self) -> bytes:
+        # Note: Returned bytes are in big endian order
+        return i2b(edu.get_secret())
+
+    def pubkey(self, key: bytes) -> bytes:
+        return edf.scalarmult_B(key)
+
+    def encodeKey(self, vk: bytes) -> str:
+        return vk[::-1].hex()
+
+    def decodeKey(self, k_hex: str) -> bytes:
+        return bytes.fromhex(k_hex)[::-1]
+
+    def encodePubkey(self, pk: bytes) -> str:
+        return edu.encodepoint(pk)
+
+    def decodePubkey(self, pke):
+        return edf.decodepoint(pke)
+
+    def getPubkey(self, privkey):
+        return ed25519_get_pubkey(privkey)
+
+    def getAddressFromKeys(self, key_view: bytes, key_spend: bytes) -> str:
+        pk_view = self.getPubkey(key_view)
+        pk_spend = self.getPubkey(key_spend)
+        return xmr_util.encode_address(pk_view, pk_spend)
+
+    def verifyKey(self, k: int) -> bool:
+        i = b2i(k)
+        return (i < edf.l and i > 8)
+
+    def verifyPubkey(self, pubkey_bytes):
+        # Calls ed25519_decode_check_point() in secp256k1
+        # Checks for small order
+        return verify_ed25519_point(pubkey_bytes)
+
+    def proveDLEAG(self, key: bytes) -> bytes:
+        privkey = PrivateKey(key)
+        return dleag_prove(privkey)
+
+    def verifyDLEAG(self, dleag_bytes: bytes) -> bool:
+        return dleag_verify(dleag_bytes)
+
+    def lengthDLEAG(self) -> int:
+        return dleag_proof_len()
+
+    def sumKeys(self, ka: bytes, kb: bytes) -> bytes:
+        return ed25519_scalar_add(ka, kb)
+
+    def sumPubkeys(self, Ka: bytes, Kb: bytes) -> bytes:
+        return ed25519_add(Ka, Kb)
+
+    def encodeSharedAddress(self, Kbv: bytes, Kbs: bytes) -> str:
+        return xmr_util.encode_address(Kbv, Kbs)
+
+    def publishBLockTx(self, kbv: bytes, Kbs: bytes, output_amount: int, feerate: int, delay_for: int = 10, unlock_time: int = 0) -> bytes:
+        with self._mx_wallet:
+            self.openWallet(self._wallet_filename)
+            self.rpc_wallet('refresh')
+
+            Kbv = self.getPubkey(kbv)
+            shared_addr = xmr_util.encode_address(Kbv, Kbs)
+
+            params = {'destinations': [{'amount': output_amount, 'address': shared_addr}], 'unlock_time': unlock_time}
+            if self._fee_priority > 0:
+                params['priority'] = self._fee_priority
+            rv = self.rpc_wallet('transfer', params)
+            self._log.info('publishBLockTx %s to address_b58 %s', rv['tx_hash'], shared_addr)
+            tx_hash = bytes.fromhex(rv['tx_hash'])
+
+            if self._sc.debug:
+                i = 0
+                while not self._sc.delay_event.is_set():
+                    gt_params = {'out': True, 'pending': True, 'failed': True, 'pool': True, }
+                    rv = self.rpc_wallet('get_transfers', gt_params)
+                    self._log.debug('get_transfers {}'.format(dumpj(rv)))
+                    if 'pending' not in rv:
+                        break
+                    if i >= delay_for:
+                        break
+                    self._sc.delay_event.wait(1.0)
+
+            return tx_hash
+
+    def findTxB(self, kbv, Kbs, cb_swap_value, cb_block_confirmed, restore_height, bid_sender):
+        with self._mx_wallet:
+            Kbv = self.getPubkey(kbv)
+            address_b58 = xmr_util.encode_address(Kbv, Kbs)
+
+            kbv_le = kbv[::-1]
+            params = {
+                'restore_height': restore_height,
+                'filename': address_b58,
+                'address': address_b58,
+                'viewkey': b2h(kbv_le),
+            }
+
+            try:
+                self.openWallet(address_b58)
+            except Exception as e:
+                self.createWallet(params)
+                self.openWallet(address_b58)
+
+            self.rpc_wallet('refresh', timeout=self._walletrpctimeoutlong)
+
+            '''
+            # Debug
+            try:
+                current_height = self.rpc_wallet('get_height')['height']
+                self._log.info('findTxB XMR current_height %d\nAddress: %s', current_height, address_b58)
+            except Exception as e:
+                self._log.info('rpc failed %s', str(e))
+                current_height = None  # If the transfer is available it will be deep enough
+                #   and (current_height is None or current_height - transfer['block_height'] > cb_block_confirmed):
+            '''
+            params = {'transfer_type': 'available'}
+            transfers = self.rpc_wallet('incoming_transfers', params)
+            rv = None
+            if 'transfers' in transfers:
+                for transfer in transfers['transfers']:
+                    # unlocked <- wallet->is_transfer_unlocked() checks unlock_time and CRYPTONOTE_DEFAULT_TX_SPENDABLE_AGE
+                    if not transfer['unlocked']:
+                        full_tx = self.rpc_wallet('get_transfer_by_txid', {'txid': transfer['tx_hash']})
+                        unlock_time = full_tx['transfer']['unlock_time']
+                        if unlock_time != 0:
+                            self._log.warning('Coin b lock txn is locked: {}, unlock_time {}'.format(transfer['tx_hash'], unlock_time))
+                            rv = -1
+                            continue
+                    if transfer['amount'] == cb_swap_value:
+                        return {'txid': transfer['tx_hash'], 'amount': transfer['amount'], 'height': 0 if 'block_height' not in transfer else transfer['block_height']}
+                    else:
+                        self._log.warning('Incorrect amount detected for coin b lock txn: {}'.format(transfer['tx_hash']))
+                        rv = -1
+            return rv
+
+    def findTxnByHash(self, txid):
+        with self._mx_wallet:
+            self.openWallet(self._wallet_filename)
+            self.rpc_wallet('refresh', timeout=self._walletrpctimeoutlong)
+
+            try:
+                current_height = self.rpc2('get_height', timeout=self._rpctimeout)['height']
+                self._log.info('findTxnByHash XMR current_height %d\nhash: %s', current_height, txid)
+            except Exception as e:
+                self._log.info('rpc failed %s', str(e))
+                current_height = None  # If the transfer is available it will be deep enough
+
+            params = {'transfer_type': 'available'}
+            rv = self.rpc_wallet('incoming_transfers', params)
+            if 'transfers' in rv:
+                for transfer in rv['transfers']:
+                    if transfer['tx_hash'] == txid \
+                       and (current_height is None or current_height - transfer['block_height'] > self.blocks_confirmed):
+                        return {'txid': transfer['tx_hash'], 'amount': transfer['amount'], 'height': transfer['block_height']}
+
+            return None
+
+    def spendBLockTx(self, chain_b_lock_txid: bytes, address_to: str, kbv: bytes, kbs: bytes, cb_swap_value: int, b_fee_rate: int, restore_height: int, spend_actual_balance: bool = False) -> bytes:
+        '''
+        Notes:
+        "Error: No unlocked balance in the specified subaddress(es)" can mean not enough funds after tx fee.
+        '''
+        with self._mx_wallet:
+            Kbv = self.getPubkey(kbv)
+            Kbs = self.getPubkey(kbs)
+            address_b58 = xmr_util.encode_address(Kbv, Kbs)
+
+            wallet_filename = address_b58 + '_spend'
+
+            params = {
+                'filename': wallet_filename,
+                'address': address_b58,
+                'viewkey': b2h(kbv[::-1]),
+                'spendkey': b2h(kbs[::-1]),
+                'restore_height': restore_height,
+            }
+
+            try:
+                self.openWallet(wallet_filename)
+            except Exception as e:
+                self.createWallet(params)
+                self.openWallet(wallet_filename)
+
+            self.rpc_wallet('refresh')
+            rv = self.rpc_wallet('get_balance')
+            if rv['balance'] < cb_swap_value:
+                self._log.warning('Balance is too low, checking for existing spend.')
+                txns = self.rpc_wallet('get_transfers', {'out': True})
+                if 'out' in txns:
+                    txns = txns['out']
+                    if len(txns) > 0:
+                        txid = txns[0]['txid']
+                        self._log.warning(f'spendBLockTx detected spending tx: {txid}.')
+                        if txns[0]['address'] == address_b58:
+                            return bytes.fromhex(txid)
+
+                self._log.error('wallet {} balance {}, expected {}'.format(wallet_filename, rv['balance'], cb_swap_value))
+
+                if not spend_actual_balance:
+                    raise TemporaryError('Invalid balance')
+
+            if spend_actual_balance and rv['balance'] != cb_swap_value:
+                self._log.warning('Spending actual balance {}, not swap value {}.'.format(rv['balance'], cb_swap_value))
+                cb_swap_value = rv['balance']
+            if rv['unlocked_balance'] < cb_swap_value:
+                self._log.error('wallet {} balance {}, expected {}, blocks_to_unlock {}'.format(wallet_filename, rv['unlocked_balance'], cb_swap_value, rv['blocks_to_unlock']))
+                raise TemporaryError('Invalid unlocked_balance')
+
+            params = {'address': address_to}
+            if self._fee_priority > 0:
+                params['priority'] = self._fee_priority
+
+            rv = self.rpc_wallet('sweep_all', params)
+            self._log.debug('sweep_all {}'.format(json.dumps(rv)))
+
+            return bytes.fromhex(rv['tx_hash_list'][0])
+
+    def withdrawCoin(self, value: int, addr_to: str, subfee: bool) -> str:
+        with self._mx_wallet:
+            value_sats = make_int(value, self.exp())
+
+            self.openWallet(self._wallet_filename)
+            self.rpc_wallet('refresh')
+
+            if subfee:
+                balance = self.rpc_wallet('get_balance')
+                diff = balance['unlocked_balance'] - value_sats
+                if diff >= 0 and diff <= 10:
+                    self._log.info('subfee enabled and value close to total, using sweep_all.')
+                    params = {'address': addr_to}
+                    if self._fee_priority > 0:
+                        params['priority'] = self._fee_priority
+                    rv = self.rpc_wallet('sweep_all', params)
+                    return rv['tx_hash_list'][0]
+                raise ValueError('Withdraw value must be close to total to use subfee/sweep_all.')
+
+            params = {'destinations': [{'amount': value_sats, 'address': addr_to}]}
+            if self._fee_priority > 0:
+                params['priority'] = self._fee_priority
+            rv = self.rpc_wallet('transfer', params)
+            return rv['tx_hash']
+
+    def showLockTransfers(self, kbv, Kbs, restore_height):
+        with self._mx_wallet:
+            try:
+                Kbv = self.getPubkey(kbv)
+                address_b58 = xmr_util.encode_address(Kbv, Kbs)
+                wallet_file = address_b58 + '_spend'
+                try:
+                    self.openWallet(wallet_file)
+                except Exception:
+                    wallet_file = address_b58
+                    try:
+                        self.openWallet(wallet_file)
+                    except Exception:
+                        self._log.info(f'showLockTransfers trying to create wallet for address {address_b58}.')
+                        kbv_le = kbv[::-1]
+                        params = {
+                            'restore_height': restore_height,
+                            'filename': address_b58,
+                            'address': address_b58,
+                            'viewkey': b2h(kbv_le),
+                        }
+                        self.createWallet(params)
+                        self.openWallet(address_b58)
+
+                self.rpc_wallet('refresh')
+
+                rv = self.rpc_wallet('get_transfers', {'in': True, 'out': True, 'pending': True, 'failed': True})
+                rv['filename'] = wallet_file
+                return rv
+            except Exception as e:
+                return {'error': str(e)}
+
+    def getSpendableBalance(self) -> int:
+        with self._mx_wallet:
+            self.openWallet(self._wallet_filename)
+
+            self.rpc_wallet('refresh')
+            balance_info = self.rpc_wallet('get_balance')
+            return balance_info['unlocked_balance']
+
+    def changeWalletPassword(self, old_password, new_password):
+        self._log.info('changeWalletPassword - {}'.format(self.ticker()))
+        orig_password = self._wallet_password
+        if old_password != '':
+            self._wallet_password = old_password
+        try:
+            self.openWallet(self._wallet_filename)
+            self.rpc_wallet('change_wallet_password', {'old_password': old_password, 'new_password': new_password})
+        except Exception as e:
+            self._wallet_password = orig_password
+            raise e
+
+    def unlockWallet(self, password: str) -> None:
+        self._log.info('unlockWallet - {}'.format(self.ticker()))
+        self._wallet_password = password
+
+        if not self._have_checked_seed:
+            self._sc.checkWalletSeed(self.coin_type())
+
+    def lockWallet(self) -> None:
+        self._log.info('lockWallet - {}'.format(self.ticker()))
+        self._wallet_password = None
+
+    def isAddressMine(self, address):
+        # TODO
+        return True
+
+    def ensureFunds(self, amount: int) -> None:
+        if self.getSpendableBalance() < amount:
+            raise ValueError('Balance too low')
+
+    def getTransaction(self, txid: bytes):
+        return self.rpc2('get_transactions', {'txs_hashes': [txid.hex(), ]})

basicswap/interface_ltc.py

@@ -1,15 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-
-# Copyright (c) 2020 tecnovert
-# Distributed under the MIT software license, see the accompanying
-# file LICENSE or http://www.opensource.org/licenses/mit-license.php.
-
-from .interface_btc import BTCInterface
-from .chainparams import Coins
-
-
-class LTCInterface(BTCInterface):
-    @staticmethod
-    def coin_type():
-        return Coins.LTC

basicswap/interface_nmc.py

@@ -1,18 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-
-# Copyright (c) 2020-2021 tecnovert
-# Distributed under the MIT software license, see the accompanying
-# file LICENSE or http://www.opensource.org/licenses/mit-license.php.
-
-from .interface_btc import BTCInterface
-from .chainparams import Coins
-
-
-class NMCInterface(BTCInterface):
-    @staticmethod
-    def coin_type():
-        return Coins.NMC
-
-    def getLockTxHeight(self, txid, dest_address, bid_amount, rescan_from, find_index=False):
-        raise ValueError('TODO: Use scantxoutset')

basicswap/interface_xmr.py

@@ -1,486 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-
-# Copyright (c) 2020-2021 tecnovert
-# Distributed under the MIT software license, see the accompanying
-# file LICENSE or http://www.opensource.org/licenses/mit-license.php.
-
-import time
-import logging
-
-import basicswap.contrib.ed25519_fast as edf
-import basicswap.ed25519_fast_util as edu
-import basicswap.util_xmr as xmr_util
-from coincurve.ed25519 import (
-    ed25519_get_pubkey,
-    ed25519_scalar_add,
-    ed25519_add)
-from coincurve.keys import PrivateKey
-from coincurve.dleag import (
-    verify_ed25519_point,
-    dleag_proof_len,
-    dleag_verify,
-    dleag_prove)
-
-from .util import (
-    ensure,
-    dumpj,
-    make_int,
-    TemporaryError)
-from .rpc_xmr import (
-    make_xmr_rpc_func,
-    make_xmr_rpc2_func,
-    make_xmr_wallet_rpc_func)
-from .ecc_util import (
-    b2i, b2h)
-from .chainparams import CoinInterface, Coins
-
-XMR_COIN = 10 ** 12
-
-
-class XMRInterface(CoinInterface):
-    @staticmethod
-    def coin_type():
-        return Coins.XMR
-
-    @staticmethod
-    def COIN():
-        return XMR_COIN
-
-    @staticmethod
-    def exp() -> int:
-        return 12
-
-    @staticmethod
-    def nbk() -> int:
-        return 32
-
-    @staticmethod
-    def nbK() -> int:  # No. of bytes requires to encode a public key
-        return 32
-
-    @staticmethod
-    def depth_spendable() -> int:
-        return 10
-
-    def __init__(self, coin_settings, network, swap_client=None):
-        super().__init__(network)
-        self.rpc_cb = make_xmr_rpc_func(coin_settings['rpcport'], host=coin_settings.get('rpchost', '127.0.0.1'))
-        self.rpc_cb2 = make_xmr_rpc2_func(coin_settings['rpcport'], host=coin_settings.get('rpchost', '127.0.0.1'))  # non-json endpoint
-        self.rpc_wallet_cb = make_xmr_wallet_rpc_func(coin_settings['walletrpcport'], coin_settings['walletrpcauth'])
-
-        self.blocks_confirmed = coin_settings['blocks_confirmed']
-        self._restore_height = coin_settings.get('restore_height', 0)
-        self.setFeePriority(coin_settings.get('fee_priority', 0))
-        self._sc = swap_client
-        self._log = self._sc.log if self._sc and self._sc.log else logging
-
-    def setFeePriority(self, new_priority):
-        ensure(new_priority >= 0 and new_priority < 4, 'Invalid fee_priority value')
-        self._fee_priority = new_priority
-
-    def setWalletFilename(self, wallet_filename):
-        self._wallet_filename = wallet_filename
-
-    def initialiseWallet(self, key_view, key_spend, restore_height=None):
-        with self._mx_wallet:
-            try:
-                self.rpc_wallet_cb('open_wallet', {'filename': self._wallet_filename})
-                # TODO: Check address
-                return  # Wallet exists
-            except Exception as e:
-                pass
-
-            Kbv = self.getPubkey(key_view)
-            Kbs = self.getPubkey(key_spend)
-            address_b58 = xmr_util.encode_address(Kbv, Kbs)
-
-            params = {
-                'filename': self._wallet_filename,
-                'address': address_b58,
-                'viewkey': b2h(key_view[::-1]),
-                'spendkey': b2h(key_spend[::-1]),
-                'restore_height': self._restore_height,
-            }
-            rv = self.rpc_wallet_cb('generate_from_keys', params)
-            self._log.info('generate_from_keys %s', dumpj(rv))
-            self.rpc_wallet_cb('open_wallet', {'filename': self._wallet_filename})
-
-    def ensureWalletExists(self):
-        with self._mx_wallet:
-            self.rpc_wallet_cb('open_wallet', {'filename': self._wallet_filename})
-
-    def testDaemonRPC(self):
-        self.rpc_wallet_cb('get_languages')
-
-    def getDaemonVersion(self):
-        return self.rpc_wallet_cb('get_version')['version']
-
-    def getBlockchainInfo(self):
-        rv = {}
-
-        # get_block_count returns "Internal error" if bootstrap-daemon is active
-        # rv['blocks'] = self.rpc_cb('get_block_count')['count']
-        rv['blocks'] = self.rpc_cb2('get_height', timeout=30)['height']
-
-        # sync_info = self.rpc_cb('sync_info', timeout=30)
-        # rv['verificationprogress'] = 0.0 if 'spans' in sync_info else 1.0
-        rv['verificationprogress'] = 0.0
-
-        return rv
-
-    def getChainHeight(self):
-        # get_block_count returns "Internal error" if bootstrap-daemon is active
-        # return self.rpc_cb('get_info')['height']
-        # return self.rpc_cb('get_block_count')['count']
-        return self.rpc_cb2('get_height', timeout=30)['height']
-
-    def getWalletInfo(self):
-        with self._mx_wallet:
-            self.rpc_wallet_cb('open_wallet', {'filename': self._wallet_filename})
-            rv = {}
-            self.rpc_wallet_cb('refresh')
-            balance_info = self.rpc_wallet_cb('get_balance')
-            rv['balance'] = self.format_amount(balance_info['unlocked_balance'])
-            rv['unconfirmed_balance'] = self.format_amount(balance_info['balance'] - balance_info['unlocked_balance'])
-            return rv
-
-    def walletRestoreHeight(self):
-        return self._restore_height
-
-    def getMainWalletAddress(self):
-        with self._mx_wallet:
-            self.rpc_wallet_cb('open_wallet', {'filename': self._wallet_filename})
-            return self.rpc_wallet_cb('get_address')['address']
-
-    def getNewAddress(self, placeholder):
-        with self._mx_wallet:
-            self._log.warning('TODO - subaddress?')
-            self.rpc_wallet_cb('open_wallet', {'filename': self._wallet_filename})
-            return self.rpc_wallet_cb('create_address', {'account_index': 0})['address']
-
-    def get_fee_rate(self, conf_target=2):
-        self._log.warning('TODO - estimate fee rate?')
-        return 0.0, 'unused'
-
-    def getNewSecretKey(self):
-        return edu.get_secret()
-
-    def pubkey(self, key):
-        return edf.scalarmult_B(key)
-
-    def encodeKey(self, vk):
-        return vk.hex()
-
-    def encodePubkey(self, pk):
-        return edu.encodepoint(pk)
-
-    def decodePubkey(self, pke):
-        return edf.decodepoint(pke)
-
-    def getPubkey(self, privkey):
-        return ed25519_get_pubkey(privkey)
-
-    def getAddressFromKeys(self, key_view, key_spend):
-        pk_view = self.getPubkey(key_view)
-        pk_spend = self.getPubkey(key_spend)
-        return xmr_util.encode_address(pk_view, pk_spend)
-
-    def verifyKey(self, k):
-        i = b2i(k)
-        return(i < edf.l and i > 8)
-
-    def verifyPubkey(self, pubkey_bytes):
-        # Calls ed25519_decode_check_point() in secp256k1
-        # Checks for small order
-        return verify_ed25519_point(pubkey_bytes)
-
-    def proveDLEAG(self, key):
-        privkey = PrivateKey(key)
-        return dleag_prove(privkey)
-
-    def verifyDLEAG(self, dleag_bytes):
-        return dleag_verify(dleag_bytes)
-
-    def lengthDLEAG(self):
-        return dleag_proof_len()
-
-    def decodeKey(self, k_hex):
-        return bytes.fromhex(k_hex)
-
-    def sumKeys(self, ka, kb):
-        return ed25519_scalar_add(ka, kb)
-
-    def sumPubkeys(self, Ka, Kb):
-        return ed25519_add(Ka, Kb)
-
-    def encodeSharedAddress(self, Kbv, Kbs):
-        return xmr_util.encode_address(Kbv, Kbs)
-
-    def publishBLockTx(self, Kbv, Kbs, output_amount, feerate):
-        with self._mx_wallet:
-            self.rpc_wallet_cb('open_wallet', {'filename': self._wallet_filename})
-
-            shared_addr = xmr_util.encode_address(Kbv, Kbs)
-
-            params = {'destinations': [{'amount': output_amount, 'address': shared_addr}]}
-            if self._fee_priority > 0:
-                params['priority'] = self._fee_priority
-            rv = self.rpc_wallet_cb('transfer', params)
-            self._log.info('publishBLockTx %s to address_b58 %s', rv['tx_hash'], shared_addr)
-            tx_hash = bytes.fromhex(rv['tx_hash'])
-
-            # Debug
-            for i in range(10):
-                params = {'out': True, 'pending': True, 'failed': True, 'pool': True, }
-                rv = self.rpc_wallet_cb('get_transfers', params)
-                self._log.info('[rm] get_transfers {}'.format(dumpj(rv)))
-                if 'pending' not in rv:
-                    break
-                time.sleep(1)
-
-            return tx_hash
-
-    def findTxB(self, kbv, Kbs, cb_swap_value, cb_block_confirmed, restore_height, bid_sender):
-        with self._mx_wallet:
-            Kbv = self.getPubkey(kbv)
-            address_b58 = xmr_util.encode_address(Kbv, Kbs)
-
-            try:
-                self.rpc_wallet_cb('close_wallet')
-            except Exception as e:
-                self._log.warning('close_wallet failed %s', str(e))
-
-            kbv_le = kbv[::-1]
-            params = {
-                'restore_height': restore_height,
-                'filename': address_b58,
-                'address': address_b58,
-                'viewkey': b2h(kbv_le),
-            }
-
-            try:
-                rv = self.rpc_wallet_cb('open_wallet', {'filename': address_b58})
-            except Exception as e:
-                rv = self.rpc_wallet_cb('generate_from_keys', params)
-                self._log.info('generate_from_keys %s', dumpj(rv))
-                rv = self.rpc_wallet_cb('open_wallet', {'filename': address_b58})
-
-            self.rpc_wallet_cb('refresh', timeout=600)
-
-            '''
-            # Debug
-            try:
-                current_height = self.rpc_wallet_cb('get_height')['height']
-                self._log.info('findTxB XMR current_height %d\nAddress: %s', current_height, address_b58)
-            except Exception as e:
-                self._log.info('rpc_cb failed %s', str(e))
-                current_height = None  # If the transfer is available it will be deep enough
-                #   and (current_height is None or current_height - transfer['block_height'] > cb_block_confirmed):
-            '''
-            params = {'transfer_type': 'available'}
-            rv = self.rpc_wallet_cb('incoming_transfers', params)
-            if 'transfers' in rv:
-                for transfer in rv['transfers']:
-                    if transfer['amount'] == cb_swap_value:
-                        return {'txid': transfer['tx_hash'], 'amount': transfer['amount'], 'height': 0 if 'block_height' not in transfer else transfer['block_height']}
-                    else:
-                        self._log.warning('Incorrect amount detected for coin b lock txn: {}'.format(transfer['tx_hash']))
-                        return -1
-            return None
-
-    def waitForLockTxB(self, kbv, Kbs, cb_swap_value, cb_block_confirmed, restore_height):
-        with self._mx_wallet:
-            Kbv_enc = self.encodePubkey(self.pubkey(kbv))
-            address_b58 = xmr_util.encode_address(Kbv_enc, self.encodePubkey(Kbs))
-
-            try:
-                self.rpc_wallet_cb('close_wallet')
-            except Exception as e:
-                self._log.warning('close_wallet failed %s', str(e))
-
-            params = {
-                'filename': address_b58,
-                'address': address_b58,
-                'viewkey': b2h(kbv[::-1]),
-                'restore_height': restore_height,
-            }
-            self.rpc_wallet_cb('generate_from_keys', params)
-
-            self.rpc_wallet_cb('open_wallet', {'filename': address_b58})
-            # For a while after opening the wallet rpc cmds return empty data
-
-            num_tries = 40
-            for i in range(num_tries + 1):
-                try:
-                    current_height = self.rpc_cb2('get_height')['height']
-                    print('current_height', current_height)
-                except Exception as e:
-                    self._log.warning('rpc_cb failed %s', str(e))
-                    current_height = None  # If the transfer is available it will be deep enough
-
-                # TODO: Make accepting current_height == None a user selectable option
-                #       Or look for all transfers and check height
-
-                params = {'transfer_type': 'available'}
-                rv = self.rpc_wallet_cb('incoming_transfers', params)
-                print('rv', rv)
-
-                if 'transfers' in rv:
-                    for transfer in rv['transfers']:
-                        if transfer['amount'] == cb_swap_value \
-                           and (current_height is None or current_height - transfer['block_height'] > cb_block_confirmed):
-                            return True
-
-                # TODO: Is it necessary to check the address?
-
-                '''
-                rv = self.rpc_wallet_cb('get_balance')
-                print('get_balance', rv)
-
-                if 'per_subaddress' in rv:
-                    for sub_addr in rv['per_subaddress']:
-                        if sub_addr['address'] == address_b58:
-
-                '''
-
-                if i >= num_tries:
-                    raise ValueError('Balance not confirming on node')
-                time.sleep(1)
-
-            return False
-
-    def findTxnByHash(self, txid):
-        with self._mx_wallet:
-            self.rpc_wallet_cb('open_wallet', {'filename': self._wallet_filename})
-            self.rpc_wallet_cb('refresh')
-
-            try:
-                current_height = self.rpc_cb2('get_height', timeout=30)['height']
-                self._log.info('findTxnByHash XMR current_height %d\nhash: %s', current_height, txid)
-            except Exception as e:
-                self._log.info('rpc_cb failed %s', str(e))
-                current_height = None  # If the transfer is available it will be deep enough
-
-            params = {'transfer_type': 'available'}
-            rv = self.rpc_wallet_cb('incoming_transfers', params)
-            if 'transfers' in rv:
-                for transfer in rv['transfers']:
-                    if transfer['tx_hash'] == txid \
-                       and (current_height is None or current_height - transfer['block_height'] > self.blocks_confirmed):
-                        return {'txid': transfer['tx_hash'], 'amount': transfer['amount'], 'height': transfer['block_height']}
-
-            return None
-
-    def spendBLockTx(self, chain_b_lock_txid, address_to, kbv, kbs, cb_swap_value, b_fee_rate, restore_height, spend_actual_balance=False):
-        with self._mx_wallet:
-            Kbv = self.getPubkey(kbv)
-            Kbs = self.getPubkey(kbs)
-            address_b58 = xmr_util.encode_address(Kbv, Kbs)
-
-            try:
-                self.rpc_wallet_cb('close_wallet')
-            except Exception as e:
-                self._log.warning('close_wallet failed %s', str(e))
-
-            wallet_filename = address_b58 + '_spend'
-
-            params = {
-                'filename': wallet_filename,
-                'address': address_b58,
-                'viewkey': b2h(kbv[::-1]),
-                'spendkey': b2h(kbs[::-1]),
-                'restore_height': restore_height,
-            }
-
-            try:
-                self.rpc_wallet_cb('open_wallet', {'filename': wallet_filename})
-            except Exception as e:
-                rv = self.rpc_wallet_cb('generate_from_keys', params)
-                self._log.info('generate_from_keys %s', dumpj(rv))
-                self.rpc_wallet_cb('open_wallet', {'filename': wallet_filename})
-
-            self.rpc_wallet_cb('refresh')
-            rv = self.rpc_wallet_cb('get_balance')
-
-            if rv['balance'] < cb_swap_value:
-                self._log.warning('Balance is too low, checking for existing spend.')
-                txns = self.rpc_wallet_cb('get_transfers', {'out': True})
-                if 'out' in txns:
-                    txns = txns['out']
-                    if len(txns) > 0:
-                        txid = txns[0]['txid']
-                        self._log.warning(f'spendBLockTx detected spending tx: {txid}.')
-                        if txns[0]['address'] == address_b58:
-                            return bytes.fromhex(txid)
-
-                self._log.error('wallet {} balance {}, expected {}'.format(wallet_filename, rv['balance'], cb_swap_value))
-
-                if not spend_actual_balance:
-                    raise TemporaryError('Invalid balance')
-
-            if spend_actual_balance and rv['balance'] != cb_swap_value:
-                self._log.warning('Spending actual balance {}, not swap value {}.'.format(rv['balance'], cb_swap_value))
-                cb_swap_value = rv['balance']
-            if rv['unlocked_balance'] < cb_swap_value:
-                self._log.error('wallet {} balance {}, expected {}, blocks_to_unlock {}'.format(wallet_filename, rv['unlocked_balance'], cb_swap_value, rv['blocks_to_unlock']))
-                raise TemporaryError('Invalid unlocked_balance')
-
-            params = {'address': address_to}
-            if self._fee_priority > 0:
-                params['priority'] = self._fee_priority
-
-            rv = self.rpc_wallet_cb('sweep_all', params)
-            print('sweep_all', rv)
-
-            return bytes.fromhex(rv['tx_hash_list'][0])
-
-    def withdrawCoin(self, value, addr_to, subfee):
-        with self._mx_wallet:
-            value_sats = make_int(value, self.exp())
-
-            self.rpc_wallet_cb('open_wallet', {'filename': self._wallet_filename})
-
-            if subfee:
-                balance = self.rpc_wallet_cb('get_balance')
-                if balance['unlocked_balance'] - value_sats <= 10:
-                    self._log.info('subfee enabled and value close to total, using sweep_all.')
-                    params = {'address': addr_to}
-                    if self._fee_priority > 0:
-                        params['priority'] = self._fee_priority
-                    rv = self.rpc_wallet_cb('sweep_all', params)
-                    return rv['tx_hash_list'][0]
-                raise ValueError('Withdraw value must be close to total to use subfee/sweep_all.')
-
-            params = {'destinations': [{'amount': value_sats, 'address': addr_to}]}
-            if self._fee_priority > 0:
-                params['priority'] = self._fee_priority
-            rv = self.rpc_wallet_cb('transfer', params)
-            return rv['tx_hash']
-
-    def showLockTransfers(self, Kbv, Kbs):
-        with self._mx_wallet:
-            try:
-                address_b58 = xmr_util.encode_address(Kbv, Kbs)
-                wallet_file = address_b58 + '_spend'
-                try:
-                    self.rpc_wallet_cb('open_wallet', {'filename': wallet_file})
-                except Exception:
-                    wallet_file = address_b58
-                    self.rpc_wallet_cb('open_wallet', {'filename': wallet_file})
-
-                self.rpc_wallet_cb('refresh')
-
-                rv = self.rpc_wallet_cb('get_transfers', {'in': True, 'out': True, 'pending': True, 'failed': True})
-                rv['filename'] = wallet_file
-                return rv
-            except Exception as e:
-                return {'error': str(e)}
-
-    def getSpendableBalance(self):
-        with self._mx_wallet:
-            self.rpc_wallet_cb('open_wallet', {'filename': self._wallet_filename})
-
-            self.rpc_wallet_cb('refresh')
-            balance_info = self.rpc_wallet_cb('get_balance')
-            return balance_info['unlocked_balance']

basicswap/js_server.py

@@ -1,24 +1,29 @@
 # -*- coding: utf-8 -*-
 
-# Copyright (c) 2020-2021 tecnovert
+# Copyright (c) 2020-2024 tecnovert
 # Distributed under the MIT software license, see the accompanying
 # file LICENSE or http://www.opensource.org/licenses/mit-license.php.
 
 import json
+import random
 import urllib.parse
 
 from .util import (
+    ensure,
     toBool,
 )
 from .basicswap_util import (
     strBidState,
     SwapTypes,
+    NotificationTypes as NT,
 )
 from .chainparams import (
     Coins,
+    chainparams,
 )
-from .ui import (
+from .ui.util import (
     PAGE_LIMIT,
+    getCoinName,
     getCoinType,
     inputAmount,
     describeBid,
@@ -27,21 +32,26 @@ from .ui import (
     get_data_entry_or,
     have_data_entry,
     tickerToCoinId,
+    listOldBidStates,
+    checkAddressesOwned,
 )
+from .ui.page_offers import postNewOffer
 from .protocols.xmr_swap_1 import recoverNoScriptTxnWithKey, getChainBSplitKey
 
 
-def js_error(self, error_str):
-    error_str_json = json.dumps({'error': error_str})
-    return bytes(error_str_json, 'UTF-8')
+def getFormData(post_string: str, is_json: bool):
+    if post_string == '':
+        raise ValueError('No post data')
+    if is_json:
+        form_data = json.loads(post_string)
+        form_data['is_json'] = True
+    else:
+        form_data = urllib.parse.parse_qs(post_string)
+    return form_data
 
 
 def withdraw_coin(swap_client, coin_type, post_string, is_json):
-    if is_json:
-        post_data = json.loads(post_string)
-        post_data['is_json'] = True
-    else:
-        post_data = urllib.parse.parse_qs(post_string)
+    post_data = getFormData(post_string, is_json)
 
     value = get_data_entry(post_data, 'value')
     address = get_data_entry(post_data, 'address')
@@ -53,13 +63,51 @@ def withdraw_coin(swap_client, coin_type, post_string, is_json):
         type_from = get_data_entry_or(post_data, 'type_from', 'plain')
         type_to = get_data_entry_or(post_data, 'type_to', 'plain')
         txid_hex = swap_client.withdrawParticl(type_from, type_to, value, address, subfee)
+    elif coin_type == Coins.LTC:
+        type_from = get_data_entry_or(post_data, 'type_from', 'plain')
+        txid_hex = swap_client.withdrawLTC(type_from, value, address, subfee)
     else:
         txid_hex = swap_client.withdrawCoin(coin_type, value, address, subfee)
 
     return {'txid': txid_hex}
 
 
+def js_error(self, error_str) -> bytes:
+    error_str_json = json.dumps({'error': error_str})
+    return bytes(error_str_json, 'UTF-8')
+
+
+def js_coins(self, url_split, post_string, is_json) -> bytes:
+    swap_client = self.server.swap_client
+
+    coins = []
+    for coin in Coins:
+        cc = swap_client.coin_clients[coin]
+        coin_chainparams = chainparams[cc['coin']]
+        coin_active: bool = False if cc['connection_type'] == 'none' else True
+        if coin == Coins.LTC_MWEB:
+            coin_active = False
+        entry = {
+            'id': int(coin),
+            'ticker': coin_chainparams['ticker'],
+            'name': getCoinName(coin),
+            'active': coin_active,
+            'decimal_places': coin_chainparams['decimal_places'],
+        }
+        if coin == Coins.PART_ANON:
+            entry['variant'] = 'Anon'
+        elif coin == Coins.PART_BLIND:
+            entry['variant'] = 'Blind'
+        elif coin == Coins.LTC_MWEB:
+            entry['variant'] = 'MWEB'
+        coins.append(entry)
+
+    return bytes(json.dumps(coins), 'UTF-8')
+
+
 def js_wallets(self, url_split, post_string, is_json):
+    swap_client = self.server.swap_client
+    swap_client.checkSystemStatus()
     if len(url_split) > 3:
         ticker_str = url_split[3]
         coin_type = tickerToCoinId(ticker_str)
@@ -67,28 +115,53 @@ def js_wallets(self, url_split, post_string, is_json):
         if len(url_split) > 4:
             cmd = url_split[4]
             if cmd == 'withdraw':
-                return bytes(json.dumps(withdraw_coin(self.server.swap_client, coin_type, post_string, is_json)), 'UTF-8')
+                return bytes(json.dumps(withdraw_coin(swap_client, coin_type, post_string, is_json)), 'UTF-8')
+            elif cmd == 'nextdepositaddr':
+                return bytes(json.dumps(swap_client.cacheNewAddressForCoin(coin_type)), 'UTF-8')
+            elif cmd == 'createutxo':
+                post_data = getFormData(post_string, is_json)
+                ci = swap_client.ci(coin_type)
+                value = ci.make_int(get_data_entry(post_data, 'value'))
+                txid_hex, new_addr = ci.createUTXO(value)
+                return bytes(json.dumps({'txid': txid_hex, 'address': new_addr}), 'UTF-8')
+            elif cmd == 'reseed':
+                swap_client.reseedWallet(coin_type)
+                return bytes(json.dumps({'reseeded': True}), 'UTF-8')
+            elif cmd == 'newstealthaddress':
+                if coin_type != Coins.PART:
+                    raise ValueError('Invalid coin for command')
+                return bytes(json.dumps(swap_client.ci(coin_type).getNewStealthAddress()), 'UTF-8')
+            elif cmd == 'newmwebaddress':
+                if coin_type not in (Coins.LTC, Coins.LTC_MWEB):
+                    raise ValueError('Invalid coin for command')
+                return bytes(json.dumps(swap_client.ci(coin_type).getNewMwebAddress()), 'UTF-8')
+
             raise ValueError('Unknown command')
-        return bytes(json.dumps(self.server.swap_client.getWalletInfo(coin_type)), 'UTF-8')
-    return bytes(json.dumps(self.server.swap_client.getWalletsInfo()), 'UTF-8')
+
+        if coin_type == Coins.LTC_MWEB:
+            coin_type = Coins.LTC
+        rv = swap_client.getWalletInfo(coin_type)
+        rv.update(swap_client.getBlockchainInfo(coin_type))
+        ci = swap_client.ci(coin_type)
+        checkAddressesOwned(swap_client, ci, rv)
+        return bytes(json.dumps(rv), 'UTF-8')
+
+    return bytes(json.dumps(swap_client.getWalletsInfo({'ticker_key': True})), 'UTF-8')
 
 
-def js_offers(self, url_split, post_string, is_json, sent=False):
+def js_offers(self, url_split, post_string, is_json, sent=False) -> bytes:
+    swap_client = self.server.swap_client
+    swap_client.checkSystemStatus()
     offer_id = None
     if len(url_split) > 3:
         if url_split[3] == 'new':
-            if post_string == '':
-                raise ValueError('No post data')
-            if is_json:
-                form_data = json.loads(post_string)
-                form_data['is_json'] = True
-            else:
-                form_data = urllib.parse.parse_qs(post_string)
-            offer_id = self.postNewOffer(form_data)
+            form_data = getFormData(post_string, is_json)
+            offer_id = postNewOffer(swap_client, form_data)
             rv = {'offer_id': offer_id.hex()}
             return bytes(json.dumps(rv), 'UTF-8')
         offer_id = bytes.fromhex(url_split[3])
 
+    with_extra_info = False
     filters = {
         'coin_from': -1,
         'coin_to': -1,
@@ -102,35 +175,39 @@ def js_offers(self, url_split, post_string, is_json, sent=False):
         filters['offer_id'] = offer_id
 
     if post_string != '':
-        if is_json:
-            post_data = json.loads(post_string)
-            post_data['is_json'] = True
-        else:
-            post_data = urllib.parse.parse_qs(post_string)
+        post_data = getFormData(post_string, is_json)
         filters['coin_from'] = setCoinFilter(post_data, 'coin_from')
         filters['coin_to'] = setCoinFilter(post_data, 'coin_to')
 
         if have_data_entry(post_data, 'sort_by'):
             sort_by = get_data_entry(post_data, 'sort_by')
-            assert(sort_by in ['created_at', 'rate']), 'Invalid sort by'
+            assert (sort_by in ['created_at', 'rate']), 'Invalid sort by'
             filters['sort_by'] = sort_by
         if have_data_entry(post_data, 'sort_dir'):
             sort_dir = get_data_entry(post_data, 'sort_dir')
-            assert(sort_dir in ['asc', 'desc']), 'Invalid sort dir'
+            assert (sort_dir in ['asc', 'desc']), 'Invalid sort dir'
             filters['sort_dir'] = sort_dir
 
-        if b'offset' in post_data:
+        if have_data_entry(post_data, 'offset'):
             filters['offset'] = int(get_data_entry(post_data, 'offset'))
-        if b'limit' in post_data:
+        if have_data_entry(post_data, 'limit'):
             filters['limit'] = int(get_data_entry(post_data, 'limit'))
-            assert(filters['limit'] > 0 and filters['limit'] <= PAGE_LIMIT), 'Invalid limit'
+            assert (filters['limit'] > 0 and filters['limit'] <= PAGE_LIMIT), 'Invalid limit'
+        if have_data_entry(post_data, 'active'):
+            filters['active'] = get_data_entry(post_data, 'active')
+        if have_data_entry(post_data, 'include_sent'):
+            filters['include_sent'] = toBool(get_data_entry(post_data, 'include_sent'))
 
-    offers = self.server.swap_client.listOffers(sent, filters)
+        if have_data_entry(post_data, 'with_extra_info'):
+            with_extra_info = toBool(get_data_entry(post_data, 'with_extra_info'))
+
+    offers = swap_client.listOffers(sent, filters)
     rv = []
     for o in offers:
-        ci_from = self.server.swap_client.ci(o.coin_from)
-        ci_to = self.server.swap_client.ci(o.coin_to)
-        rv.append({
+        ci_from = swap_client.ci(o.coin_from)
+        ci_to = swap_client.ci(o.coin_to)
+        offer_data = {
+            'swap_type': o.swap_type,
             'addr_from': o.addr_from,
             'addr_to': o.addr_to,
             'offer_id': o.offer_id.hex(),
@@ -141,32 +218,96 @@ def js_offers(self, url_split, post_string, is_json, sent=False):
             'amount_from': ci_from.format_amount(o.amount_from),
             'amount_to': ci_to.format_amount((o.amount_from * o.rate) // ci_from.COIN()),
             'rate': ci_to.format_amount(o.rate),
-        })
+        }
+        if with_extra_info:
+            offer_data['amount_negotiable'] = o.amount_negotiable
+            offer_data['rate_negotiable'] = o.rate_negotiable
 
+            if o.swap_type == SwapTypes.XMR_SWAP:
+                _, xmr_offer = swap_client.getXmrOffer(o.offer_id)
+                offer_data['lock_time_1'] = xmr_offer.lock_time_1
+                offer_data['lock_time_2'] = xmr_offer.lock_time_2
+
+                offer_data['feerate_from'] = xmr_offer.a_fee_rate
+                offer_data['feerate_to'] = xmr_offer.b_fee_rate
+            else:
+                offer_data['feerate_from'] = o.from_feerate
+                offer_data['feerate_to'] = o.to_feerate
+
+        rv.append(offer_data)
     return bytes(json.dumps(rv), 'UTF-8')
 
 
-def js_sentoffers(self, url_split, post_string, is_json):
-    return self.js_offers(url_split, post_string, is_json, True)
+def js_sentoffers(self, url_split, post_string, is_json) -> bytes:
+    return js_offers(self, url_split, post_string, is_json, True)
 
 
-def js_bids(self, url_split, post_string, is_json):
+def parseBidFilters(post_data):
+    offer_id = None
+    filters = {}
+
+    if have_data_entry(post_data, 'offer_id'):
+        offer_id = bytes.fromhex(get_data_entry(post_data, 'offer_id'))
+        assert (len(offer_id) == 28)
+
+    if have_data_entry(post_data, 'sort_by'):
+        sort_by = get_data_entry(post_data, 'sort_by')
+        assert (sort_by in ['created_at', ]), 'Invalid sort by'
+        filters['sort_by'] = sort_by
+    if have_data_entry(post_data, 'sort_dir'):
+        sort_dir = get_data_entry(post_data, 'sort_dir')
+        assert (sort_dir in ['asc', 'desc']), 'Invalid sort dir'
+        filters['sort_dir'] = sort_dir
+
+    if have_data_entry(post_data, 'offset'):
+        filters['offset'] = int(get_data_entry(post_data, 'offset'))
+    if have_data_entry(post_data, 'limit'):
+        filters['limit'] = int(get_data_entry(post_data, 'limit'))
+        assert (filters['limit'] > 0 and filters['limit'] <= PAGE_LIMIT), 'Invalid limit'
+
+    if have_data_entry(post_data, 'with_available_or_active'):
+        filters['with_available_or_active'] = toBool(get_data_entry(post_data, 'with_available_or_active'))
+    elif have_data_entry(post_data, 'with_expired'):
+        filters['with_expired'] = toBool(get_data_entry(post_data, 'with_expired'))
+
+    if have_data_entry(post_data, 'with_extra_info'):
+        filters['with_extra_info'] = toBool(get_data_entry(post_data, 'with_extra_info'))
+
+    return offer_id, filters
+
+
+def formatBids(swap_client, bids, filters) -> bytes:
+    with_extra_info = filters.get('with_extra_info', False)
+    rv = []
+    for b in bids:
+        bid_data = {
+            'bid_id': b[2].hex(),
+            'offer_id': b[3].hex(),
+            'created_at': b[0],
+            'expire_at': b[1],
+            'coin_from': b[9],
+            'amount_from': swap_client.ci(b[9]).format_amount(b[4]),
+            'bid_rate': swap_client.ci(b[14]).format_amount(b[10]),
+            'bid_state': strBidState(b[5])
+        }
+        if with_extra_info:
+            bid_data['addr_from'] = b[11]
+        rv.append(bid_data)
+    return bytes(json.dumps(rv), 'UTF-8')
+
+
+def js_bids(self, url_split, post_string: str, is_json: bool) -> bytes:
     swap_client = self.server.swap_client
+    swap_client.checkSystemStatus()
     if len(url_split) > 3:
         if url_split[3] == 'new':
-            if post_string == '':
-                raise ValueError('No post data')
-            if is_json:
-                post_data = json.loads(post_string)
-                post_data['is_json'] = True
-            else:
-                post_data = urllib.parse.parse_qs(post_string)
+            post_data = getFormData(post_string, is_json)
 
             offer_id = bytes.fromhex(get_data_entry(post_data, 'offer_id'))
-            assert(len(offer_id) == 28)
+            assert (len(offer_id) == 28)
 
             offer = swap_client.getOffer(offer_id)
-            assert(offer), 'Offer not found.'
+            assert (offer), 'Offer not found.'
 
             ci_from = swap_client.ci(offer.coin_from)
             ci_to = swap_client.ci(offer.coin_to)
@@ -205,21 +346,23 @@ def js_bids(self, url_split, post_string, is_json):
             return bytes(json.dumps(rv), 'UTF-8')
 
         bid_id = bytes.fromhex(url_split[3])
-        assert(len(bid_id) == 28)
+        assert (len(bid_id) == 28)
 
+        show_txns = False
         if post_string != '':
-            if is_json:
-                post_data = json.loads(post_string)
-                post_data['is_json'] = True
-            else:
-                post_data = urllib.parse.parse_qs(post_string)
+            post_data = getFormData(post_string, is_json)
             if have_data_entry(post_data, 'accept'):
                 swap_client.acceptBid(bid_id)
+            elif have_data_entry(post_data, 'abandon'):
+                swap_client.abandonBid(bid_id)
             elif have_data_entry(post_data, 'debugind'):
                 swap_client.setBidDebugInd(bid_id, int(get_data_entry(post_data, 'debugind')))
 
+            if have_data_entry(post_data, 'show_extra'):
+                show_txns = True
+
         bid, xmr_swap, offer, xmr_offer, events = swap_client.getXmrBidAndOffer(bid_id)
-        assert(bid), 'Unknown bid ID'
+        assert (bid), 'Unknown bid ID'
 
         if post_string != '':
             if have_data_entry(post_data, 'chainbkeysplit'):
@@ -228,48 +371,51 @@ def js_bids(self, url_split, post_string, is_json):
                 remote_key = get_data_entry(post_data, 'remote_key')
                 return bytes(json.dumps({'txid': recoverNoScriptTxnWithKey(swap_client, bid_id, remote_key).hex()}), 'UTF-8')
 
+        if len(url_split) > 4 and url_split[4] == 'states':
+            old_states = listOldBidStates(bid)
+            return bytes(json.dumps(old_states), 'UTF-8')
+
         edit_bid = False
-        show_txns = False
         data = describeBid(swap_client, bid, xmr_swap, offer, xmr_offer, events, edit_bid, show_txns, for_api=True)
         return bytes(json.dumps(data), 'UTF-8')
 
-    bids = swap_client.listBids()
-    return bytes(json.dumps([{
-        'bid_id': b[2].hex(),
-        'offer_id': b[3].hex(),
-        'created_at': b[0],
-        'expire_at': b[1],
-        'coin_from': b[9],
-        'amount_from': swap_client.ci(b[9]).format_amount(b[4]),
-        'bid_state': strBidState(b[5])
-    } for b in bids]), 'UTF-8')
+    post_data = {} if post_string == '' else getFormData(post_string, is_json)
+    offer_id, filters = parseBidFilters(post_data)
+
+    bids = swap_client.listBids(offer_id=offer_id, filters=filters)
+    return formatBids(swap_client, bids, filters)
 
 
-def js_sentbids(self, url_split, post_string, is_json):
-    return bytes(json.dumps(self.server.swap_client.listBids(sent=True)), 'UTF-8')
+def js_sentbids(self, url_split, post_string, is_json) -> bytes:
+    swap_client = self.server.swap_client
+    swap_client.checkSystemStatus()
+    post_data = getFormData(post_string, is_json)
+    offer_id, filters = parseBidFilters(post_data)
+
+    bids = swap_client.listBids(sent=True, offer_id=offer_id, filters=filters)
+    return formatBids(swap_client, bids, filters)
 
 
-def js_network(self, url_split, post_string, is_json):
-    return bytes(json.dumps(self.server.swap_client.get_network_info()), 'UTF-8')
+def js_network(self, url_split, post_string, is_json) -> bytes:
+    swap_client = self.server.swap_client
+    swap_client.checkSystemStatus()
+    return bytes(json.dumps(swap_client.get_network_info()), 'UTF-8')
 
 
-def js_revokeoffer(self, url_split, post_string, is_json):
+def js_revokeoffer(self, url_split, post_string, is_json) -> bytes:
+    swap_client = self.server.swap_client
+    swap_client.checkSystemStatus()
     offer_id = bytes.fromhex(url_split[3])
-    assert(len(offer_id) == 28)
-    self.server.swap_client.revokeOffer(offer_id)
+    assert (len(offer_id) == 28)
+    swap_client.revokeOffer(offer_id)
     return bytes(json.dumps({'revoked_offer': offer_id.hex()}), 'UTF-8')
 
 
-def js_smsgaddresses(self, url_split, post_string, is_json):
+def js_smsgaddresses(self, url_split, post_string, is_json) -> bytes:
     swap_client = self.server.swap_client
+    swap_client.checkSystemStatus()
+    post_data = {} if post_string == '' else getFormData(post_string, is_json)
     if len(url_split) > 3:
-        if post_string == '':
-            raise ValueError('No post data')
-        if is_json:
-            post_data = json.loads(post_string)
-            post_data['is_json'] = True
-        else:
-            post_data = urllib.parse.parse_qs(post_string)
         if url_split[3] == 'new':
             addressnote = get_data_entry_or(post_data, 'addressnote', '')
             new_addr, pubkey = swap_client.newSMSGAddress(addressnote=addressnote)
@@ -286,17 +432,15 @@ def js_smsgaddresses(self, url_split, post_string, is_json):
             new_addr = swap_client.editSMSGAddress(address, activeind, addressnote)
             return bytes(json.dumps({'edited_address': address}), 'UTF-8')
 
-    return bytes(json.dumps(swap_client.listAllSMSGAddresses()), 'UTF-8')
+    filters = {
+        'exclude_inactive': post_data.get('exclude_inactive', True),
+    }
+
+    return bytes(json.dumps(swap_client.listAllSMSGAddresses(filters)), 'UTF-8')
 
 
-def js_rates(self, url_split, post_string, is_json):
-    if post_string == '':
-        raise ValueError('No post data')
-    if is_json:
-        post_data = json.loads(post_string)
-        post_data['is_json'] = True
-    else:
-        post_data = urllib.parse.parse_qs(post_string)
+def js_rates(self, url_split, post_string, is_json) -> bytes:
+    post_data = getFormData(post_string, is_json)
 
     sc = self.server.swap_client
     coin_from = get_data_entry(post_data, 'coin_from')
@@ -304,14 +448,17 @@ def js_rates(self, url_split, post_string, is_json):
     return bytes(json.dumps(sc.lookupRates(coin_from, coin_to)), 'UTF-8')
 
 
-def js_rate(self, url_split, post_string, is_json):
-    if post_string == '':
-        raise ValueError('No post data')
-    if is_json:
-        post_data = json.loads(post_string)
-        post_data['is_json'] = True
-    else:
-        post_data = urllib.parse.parse_qs(post_string)
+def js_rates_list(self, url_split, query_string, is_json) -> bytes:
+    get_data = urllib.parse.parse_qs(query_string)
+
+    sc = self.server.swap_client
+    coin_from = getCoinType(get_data['from'][0])
+    coin_to = getCoinType(get_data['to'][0])
+    return bytes(json.dumps(sc.lookupRates(coin_from, coin_to, True)), 'UTF-8')
+
+
+def js_rate(self, url_split, post_string, is_json) -> bytes:
+    post_data = getFormData(post_string, is_json)
 
     sc = self.server.swap_client
     coin_from = getCoinType(get_data_entry(post_data, 'coin_from'))
@@ -343,5 +490,263 @@ def js_rate(self, url_split, post_string, is_json):
     return bytes(json.dumps({'rate': rate}), 'UTF-8')
 
 
-def js_index(self, url_split, post_string, is_json):
-    return bytes(json.dumps(self.server.swap_client.getSummary()), 'UTF-8')
+def js_index(self, url_split, post_string, is_json) -> bytes:
+    swap_client = self.server.swap_client
+    swap_client.checkSystemStatus()
+    return bytes(json.dumps(swap_client.getSummary()), 'UTF-8')
+
+
+def js_generatenotification(self, url_split, post_string, is_json) -> bytes:
+    swap_client = self.server.swap_client
+
+    if not swap_client.debug:
+        raise ValueError('Debug mode not active.')
+
+    r = random.randint(0, 3)
+    if r == 0:
+        swap_client.notify(NT.OFFER_RECEIVED, {'offer_id': random.randbytes(28).hex()})
+    elif r == 1:
+        swap_client.notify(NT.BID_RECEIVED, {'type': 'atomic', 'bid_id': random.randbytes(28).hex(), 'offer_id': random.randbytes(28).hex()})
+    elif r == 2:
+        swap_client.notify(NT.BID_ACCEPTED, {'bid_id': random.randbytes(28).hex()})
+    elif r == 3:
+        swap_client.notify(NT.BID_RECEIVED, {'type': 'ads', 'bid_id': random.randbytes(28).hex(), 'offer_id': random.randbytes(28).hex()})
+
+    return bytes(json.dumps({'type': r}), 'UTF-8')
+
+
+def js_notifications(self, url_split, post_string, is_json) -> bytes:
+    swap_client = self.server.swap_client
+    swap_client.checkSystemStatus()
+
+    return bytes(json.dumps(swap_client.getNotifications()), 'UTF-8')
+
+
+def js_identities(self, url_split, post_string: str, is_json: bool) -> bytes:
+    swap_client = self.server.swap_client
+    swap_client.checkSystemStatus()
+
+    filters = {
+        'page_no': 1,
+        'limit': PAGE_LIMIT,
+        'sort_by': 'created_at',
+        'sort_dir': 'desc',
+    }
+
+    if len(url_split) > 3:
+        address = url_split[3]
+        filters['address'] = address
+
+    if post_string != '':
+        post_data = getFormData(post_string, is_json)
+
+        if have_data_entry(post_data, 'sort_by'):
+            sort_by = get_data_entry(post_data, 'sort_by')
+            assert (sort_by in ['created_at', 'rate']), 'Invalid sort by'
+            filters['sort_by'] = sort_by
+        if have_data_entry(post_data, 'sort_dir'):
+            sort_dir = get_data_entry(post_data, 'sort_dir')
+            assert (sort_dir in ['asc', 'desc']), 'Invalid sort dir'
+            filters['sort_dir'] = sort_dir
+
+        if have_data_entry(post_data, 'offset'):
+            filters['offset'] = int(get_data_entry(post_data, 'offset'))
+        if have_data_entry(post_data, 'limit'):
+            filters['limit'] = int(get_data_entry(post_data, 'limit'))
+            assert (filters['limit'] > 0 and filters['limit'] <= PAGE_LIMIT), 'Invalid limit'
+
+        set_data = {}
+        if have_data_entry(post_data, 'set_label'):
+            set_data['label'] = get_data_entry(post_data, 'set_label')
+        if have_data_entry(post_data, 'set_automation_override'):
+            set_data['automation_override'] = get_data_entry(post_data, 'set_automation_override')
+        if have_data_entry(post_data, 'set_visibility_override'):
+            set_data['visibility_override'] = get_data_entry(post_data, 'set_visibility_override')
+        if have_data_entry(post_data, 'set_note'):
+            set_data['note'] = get_data_entry(post_data, 'set_note')
+
+        if set_data:
+            ensure('address' in filters, 'Must provide an address to modify data')
+            swap_client.setIdentityData(filters, set_data)
+
+    return bytes(json.dumps(swap_client.listIdentities(filters)), 'UTF-8')
+
+
+def js_automationstrategies(self, url_split, post_string: str, is_json: bool) -> bytes:
+    swap_client = self.server.swap_client
+    swap_client.checkSystemStatus()
+
+    filters = {
+        'page_no': 1,
+        'limit': PAGE_LIMIT,
+        'sort_by': 'created_at',
+        'sort_dir': 'desc',
+    }
+
+    if post_string != '':
+        post_data = getFormData(post_string, is_json)
+
+        if have_data_entry(post_data, 'sort_by'):
+            sort_by = get_data_entry(post_data, 'sort_by')
+            assert (sort_by in ['created_at', 'rate']), 'Invalid sort by'
+            filters['sort_by'] = sort_by
+        if have_data_entry(post_data, 'sort_dir'):
+            sort_dir = get_data_entry(post_data, 'sort_dir')
+            assert (sort_dir in ['asc', 'desc']), 'Invalid sort dir'
+            filters['sort_dir'] = sort_dir
+
+        if have_data_entry(post_data, 'offset'):
+            filters['offset'] = int(get_data_entry(post_data, 'offset'))
+        if have_data_entry(post_data, 'limit'):
+            filters['limit'] = int(get_data_entry(post_data, 'limit'))
+            assert (filters['limit'] > 0 and filters['limit'] <= PAGE_LIMIT), 'Invalid limit'
+
+    if len(url_split) > 3:
+        strat_id = int(url_split[3])
+        strat_data = swap_client.getAutomationStrategy(strat_id)
+        rv = {
+            'record_id': strat_data.record_id,
+            'label': strat_data.label,
+            'type_ind': strat_data.type_ind,
+            'only_known_identities': strat_data.only_known_identities,
+            'num_concurrent': strat_data.num_concurrent,
+            'data': json.loads(strat_data.data.decode('utf-8')),
+            'note': '' if strat_data.note is None else strat_data.note,
+        }
+        return bytes(json.dumps(rv), 'UTF-8')
+
+    rv = []
+    strats = swap_client.listAutomationStrategies(filters)
+    for row in strats:
+        rv.append((row[0], row[1], row[2]))
+    return bytes(json.dumps(rv), 'UTF-8')
+
+
+def js_vacuumdb(self, url_split, post_string, is_json) -> bytes:
+    swap_client = self.server.swap_client
+    swap_client.checkSystemStatus()
+    swap_client.vacuumDB()
+
+    return bytes(json.dumps({'completed': True}), 'UTF-8')
+
+
+def js_getcoinseed(self, url_split, post_string, is_json) -> bytes:
+    swap_client = self.server.swap_client
+    swap_client.checkSystemStatus()
+    post_data = getFormData(post_string, is_json)
+
+    coin = getCoinType(get_data_entry(post_data, 'coin'))
+    if coin in (Coins.PART, Coins.PART_ANON, Coins.PART_BLIND):
+        raise ValueError('Particl wallet seed is set from the Basicswap mnemonic.')
+
+    ci = swap_client.ci(coin)
+    if coin == Coins.XMR:
+        key_view = swap_client.getWalletKey(coin, 1, for_ed25519=True)
+        key_spend = swap_client.getWalletKey(coin, 2, for_ed25519=True)
+        address = ci.getAddressFromKeys(key_view, key_spend)
+        return bytes(json.dumps({'coin': ci.ticker(), 'key_view': ci.encodeKey(key_view), 'key_spend': ci.encodeKey(key_spend), 'address': address}), 'UTF-8')
+
+    seed_key = swap_client.getWalletKey(coin, 1)
+    if coin == Coins.DASH:
+        return bytes(json.dumps({'coin': ci.ticker(), 'seed': seed_key.hex(), 'mnemonic': ci.seedToMnemonic(seed_key)}), 'UTF-8')
+    seed_id = ci.getSeedHash(seed_key)
+    return bytes(json.dumps({'coin': ci.ticker(), 'seed': seed_key.hex(), 'seed_id': seed_id.hex()}), 'UTF-8')
+
+
+def js_setpassword(self, url_split, post_string, is_json) -> bytes:
+    # Set or change wallet passwords
+    # Only works with currently enabled coins
+    # Will fail if any coin does not unlock on the old password
+    swap_client = self.server.swap_client
+    post_data = getFormData(post_string, is_json)
+
+    old_password = get_data_entry(post_data, 'oldpassword')
+    new_password = get_data_entry(post_data, 'newpassword')
+
+    if have_data_entry(post_data, 'coin'):
+        # Set password for one coin
+        coin = getCoinType(get_data_entry(post_data, 'coin'))
+        if coin in (Coins.PART_ANON, Coins.PART_BLIND, Coins.LTC_MWEB):
+            raise ValueError('Invalid coin.')
+        swap_client.changeWalletPasswords(old_password, new_password, coin)
+        return bytes(json.dumps({'success': True}), 'UTF-8')
+
+    # Set password for all coins
+    swap_client.changeWalletPasswords(old_password, new_password)
+    return bytes(json.dumps({'success': True}), 'UTF-8')
+
+
+def js_unlock(self, url_split, post_string, is_json) -> bytes:
+    swap_client = self.server.swap_client
+    post_data = getFormData(post_string, is_json)
+
+    password = get_data_entry(post_data, 'password')
+
+    if have_data_entry(post_data, 'coin'):
+        coin = getCoinType(str(get_data_entry(post_data, 'coin')))
+        if coin in (Coins.PART_ANON, Coins.PART_BLIND):
+            raise ValueError('Invalid coin.')
+        swap_client.unlockWallets(password, coin)
+        return bytes(json.dumps({'success': True}), 'UTF-8')
+
+    swap_client.unlockWallets(password)
+    return bytes(json.dumps({'success': True}), 'UTF-8')
+
+
+def js_lock(self, url_split, post_string, is_json) -> bytes:
+    swap_client = self.server.swap_client
+    post_data = {} if post_string == '' else getFormData(post_string, is_json)
+
+    if have_data_entry(post_data, 'coin'):
+        coin = getCoinType(get_data_entry(post_data, 'coin'))
+        if coin in (Coins.PART_ANON, Coins.PART_BLIND):
+            raise ValueError('Invalid coin.')
+        swap_client.lockWallets(coin)
+        return bytes(json.dumps({'success': True}), 'UTF-8')
+
+    swap_client.lockWallets()
+    return bytes(json.dumps({'success': True}), 'UTF-8')
+
+
+def js_404(self, url_split, post_string, is_json) -> bytes:
+    return bytes(json.dumps({'Error': 'path unknown'}), 'UTF-8')
+
+
+def js_help(self, url_split, post_string, is_json) -> bytes:
+    # TODO: Add details and examples
+    commands = []
+    for k in pages:
+        commands.append(k)
+    return bytes(json.dumps({'commands': commands}), 'UTF-8')
+
+
+pages = {
+    'coins': js_coins,
+    'wallets': js_wallets,
+    'offers': js_offers,
+    'sentoffers': js_sentoffers,
+    'bids': js_bids,
+    'sentbids': js_sentbids,
+    'network': js_network,
+    'revokeoffer': js_revokeoffer,
+    'smsgaddresses': js_smsgaddresses,
+    'rate': js_rate,
+    'rates': js_rates,
+    'rateslist': js_rates_list,
+    'generatenotification': js_generatenotification,
+    'notifications': js_notifications,
+    'identities': js_identities,
+    'automationstrategies': js_automationstrategies,
+    'vacuumdb': js_vacuumdb,
+    'getcoinseed': js_getcoinseed,
+    'setpassword': js_setpassword,
+    'unlock': js_unlock,
+    'lock': js_lock,
+    'help': js_help,
+}
+
+
+def js_url_to_function(url_split):
+    if len(url_split) > 2:
+        return pages.get(url_split[2], js_404)
+    return js_index

basicswap/messages.proto

@@ -33,6 +33,8 @@ message OfferMessage {
     uint32 protocol_version = 16;
     bool amount_negotiable = 17;
     bool rate_negotiable = 18;
+
+    bytes proof_utxos = 19;          /* 32 byte txid 2 byte vout, repeated */
 }
 
 /* Step 2, buyer -> seller */
@@ -40,8 +42,21 @@ message BidMessage {
     bytes offer_msg_id = 1;
     uint64 time_valid = 2;          /* seconds bid is valid for */
     uint64 amount = 3;              /* amount of amount_from bid is for */
+    uint64 rate = 4;
+    bytes pkhash_buyer = 5;         /* buyer's address to receive amount_from */
+    string proof_address = 6;
+    string proof_signature = 7;
 
-    /* optional */
+    uint32 protocol_version = 8;
+
+    bytes proof_utxos = 9;          /* 32 byte txid 2 byte vout, repeated */
+}
+
+/* For tests */
+message BidMessage_v1Deprecated {
+    bytes offer_msg_id = 1;
+    uint64 time_valid = 2;          /* seconds bid is valid for */
+    uint64 amount = 3;              /* amount of amount_from bid is for */
     uint64 rate = 4;
     bytes pkhash_buyer = 5;         /* buyer's address to receive amount_from */
     string proof_address = 6;
@@ -50,6 +65,8 @@ message BidMessage {
     uint32 protocol_version = 8;
 }
 
+
+
 /* Step 3, seller -> buyer */
 message BidAcceptMessage {
     bytes bid_msg_id = 1;
@@ -131,3 +148,24 @@ message XmrBidLockReleaseMessage {
 
     bytes al_lock_spend_tx_esig = 2;
 }
+
+message ADSBidIntentMessage {
+    /* L -> F Sent from bidder, construct a reverse bid */
+    bytes offer_msg_id = 1;
+    uint64 time_valid = 2;          /* seconds bid is valid for */
+    uint64 amount_from = 3;         /* amount of offer.coin_from bid is for */
+    uint64 amount_to = 4;           /* amount of offer.coin_to bid is for, equivalent to bid.amount */
+    uint64 rate = 5;                /* amount of offer.coin_from bid is for */
+
+    uint32 protocol_version = 6;
+}
+
+message ADSBidIntentAcceptMessage {
+    /* F -> L Sent from offerer, construct a reverse bid */
+    bytes bid_msg_id = 1;
+
+    bytes pkaf = 2;
+    bytes kbvf = 3;
+    bytes kbsf_dleag = 4;
+    bytes dest_af = 5;
+}

basicswap/messages_pb2.py

@@ -3,9 +3,9 @@
 # source: messages.proto
 """Generated protocol buffer code."""
 from google.protobuf import descriptor as _descriptor
-from google.protobuf import message as _message
-from google.protobuf import reflection as _reflection
+from google.protobuf import descriptor_pool as _descriptor_pool
 from google.protobuf import symbol_database as _symbol_database
+from google.protobuf.internal import builder as _builder
 # @@protoc_insertion_point(imports)
 
 _sym_db = _symbol_database.Default()
@@ -13,872 +13,41 @@ _sym_db = _symbol_database.Default()
 
 
 
-DESCRIPTOR = _descriptor.FileDescriptor(
-  name='messages.proto',
-  package='basicswap',
-  syntax='proto3',
-  serialized_options=None,
-  create_key=_descriptor._internal_create_key,
-  serialized_pb=b'\n\x0emessages.proto\x12\tbasicswap\"\xa6\x04\n\x0cOfferMessage\x12\x11\n\tcoin_from\x18\x01 \x01(\r\x12\x0f\n\x07\x63oin_to\x18\x02 \x01(\r\x12\x13\n\x0b\x61mount_from\x18\x03 \x01(\x04\x12\x0c\n\x04rate\x18\x04 \x01(\x04\x12\x16\n\x0emin_bid_amount\x18\x05 \x01(\x04\x12\x12\n\ntime_valid\x18\x06 \x01(\x04\x12\x33\n\tlock_type\x18\x07 \x01(\x0e\x32 .basicswap.OfferMessage.LockType\x12\x12\n\nlock_value\x18\x08 \x01(\r\x12\x11\n\tswap_type\x18\t \x01(\r\x12\x15\n\rproof_address\x18\n \x01(\t\x12\x17\n\x0fproof_signature\x18\x0b \x01(\t\x12\x15\n\rpkhash_seller\x18\x0c \x01(\x0c\x12\x13\n\x0bsecret_hash\x18\r \x01(\x0c\x12\x15\n\rfee_rate_from\x18\x0e \x01(\x04\x12\x13\n\x0b\x66\x65\x65_rate_to\x18\x0f \x01(\x04\x12\x18\n\x10protocol_version\x18\x10 \x01(\r\x12\x19\n\x11\x61mount_negotiable\x18\x11 \x01(\x08\x12\x17\n\x0frate_negotiable\x18\x12 \x01(\x08\"q\n\x08LockType\x12\x0b\n\x07NOT_SET\x10\x00\x12\x18\n\x14SEQUENCE_LOCK_BLOCKS\x10\x01\x12\x16\n\x12SEQUENCE_LOCK_TIME\x10\x02\x12\x13\n\x0f\x41\x42S_LOCK_BLOCKS\x10\x03\x12\x11\n\rABS_LOCK_TIME\x10\x04\"\xb4\x01\n\nBidMessage\x12\x14\n\x0coffer_msg_id\x18\x01 \x01(\x0c\x12\x12\n\ntime_valid\x18\x02 \x01(\x04\x12\x0e\n\x06\x61mount\x18\x03 \x01(\x04\x12\x0c\n\x04rate\x18\x04 \x01(\x04\x12\x14\n\x0cpkhash_buyer\x18\x05 \x01(\x0c\x12\x15\n\rproof_address\x18\x06 \x01(\t\x12\x17\n\x0fproof_signature\x18\x07 \x01(\t\x12\x18\n\x10protocol_version\x18\x08 \x01(\r\"V\n\x10\x42idAcceptMessage\x12\x12\n\nbid_msg_id\x18\x01 \x01(\x0c\x12\x15\n\rinitiate_txid\x18\x02 \x01(\x0c\x12\x17\n\x0f\x63ontract_script\x18\x03 \x01(\x0c\"=\n\x12OfferRevokeMessage\x12\x14\n\x0coffer_msg_id\x18\x01 \x01(\x0c\x12\x11\n\tsignature\x18\x02 \x01(\x0c\";\n\x10\x42idRejectMessage\x12\x12\n\nbid_msg_id\x18\x01 \x01(\x0c\x12\x13\n\x0breject_code\x18\x02 \x01(\r\"\xb2\x01\n\rXmrBidMessage\x12\x14\n\x0coffer_msg_id\x18\x01 \x01(\x0c\x12\x12\n\ntime_valid\x18\x02 \x01(\x04\x12\x0e\n\x06\x61mount\x18\x03 \x01(\x04\x12\x0c\n\x04rate\x18\x04 \x01(\x04\x12\x0c\n\x04pkaf\x18\x05 \x01(\x0c\x12\x0c\n\x04kbvf\x18\x06 \x01(\x0c\x12\x12\n\nkbsf_dleag\x18\x07 \x01(\x0c\x12\x0f\n\x07\x64\x65st_af\x18\x08 \x01(\x0c\x12\x18\n\x10protocol_version\x18\t \x01(\r\"T\n\x0fXmrSplitMessage\x12\x0e\n\x06msg_id\x18\x01 \x01(\x0c\x12\x10\n\x08msg_type\x18\x02 \x01(\r\x12\x10\n\x08sequence\x18\x03 \x01(\r\x12\r\n\x05\x64leag\x18\x04 \x01(\x0c\"\x80\x02\n\x13XmrBidAcceptMessage\x12\x12\n\nbid_msg_id\x18\x01 \x01(\x0c\x12\x0c\n\x04pkal\x18\x03 \x01(\x0c\x12\x0c\n\x04kbvl\x18\x04 \x01(\x0c\x12\x12\n\nkbsl_dleag\x18\x05 \x01(\x0c\x12\x11\n\ta_lock_tx\x18\x06 \x01(\x0c\x12\x18\n\x10\x61_lock_tx_script\x18\x07 \x01(\x0c\x12\x18\n\x10\x61_lock_refund_tx\x18\x08 \x01(\x0c\x12\x1f\n\x17\x61_lock_refund_tx_script\x18\t \x01(\x0c\x12\x1e\n\x16\x61_lock_refund_spend_tx\x18\n \x01(\x0c\x12\x1d\n\x15\x61l_lock_refund_tx_sig\x18\x0b \x01(\x0c\"r\n\x17XmrBidLockTxSigsMessage\x12\x12\n\nbid_msg_id\x18\x01 \x01(\x0c\x12$\n\x1c\x61\x66_lock_refund_spend_tx_esig\x18\x02 \x01(\x0c\x12\x1d\n\x15\x61\x66_lock_refund_tx_sig\x18\x03 \x01(\x0c\"X\n\x18XmrBidLockSpendTxMessage\x12\x12\n\nbid_msg_id\x18\x01 \x01(\x0c\x12\x17\n\x0f\x61_lock_spend_tx\x18\x02 \x01(\x0c\x12\x0f\n\x07kal_sig\x18\x03 \x01(\x0c\"M\n\x18XmrBidLockReleaseMessage\x12\x12\n\nbid_msg_id\x18\x01 \x01(\x0c\x12\x1d\n\x15\x61l_lock_spend_tx_esig\x18\x02 \x01(\x0c\x62\x06proto3'
-)
-
-
-
-_OFFERMESSAGE_LOCKTYPE = _descriptor.EnumDescriptor(
-  name='LockType',
-  full_name='basicswap.OfferMessage.LockType',
-  filename=None,
-  file=DESCRIPTOR,
-  create_key=_descriptor._internal_create_key,
-  values=[
-    _descriptor.EnumValueDescriptor(
-      name='NOT_SET', index=0, number=0,
-      serialized_options=None,
-      type=None,
-      create_key=_descriptor._internal_create_key),
-    _descriptor.EnumValueDescriptor(
-      name='SEQUENCE_LOCK_BLOCKS', index=1, number=1,
-      serialized_options=None,
-      type=None,
-      create_key=_descriptor._internal_create_key),
-    _descriptor.EnumValueDescriptor(
-      name='SEQUENCE_LOCK_TIME', index=2, number=2,
-      serialized_options=None,
-      type=None,
-      create_key=_descriptor._internal_create_key),
-    _descriptor.EnumValueDescriptor(
-      name='ABS_LOCK_BLOCKS', index=3, number=3,
-      serialized_options=None,
-      type=None,
-      create_key=_descriptor._internal_create_key),
-    _descriptor.EnumValueDescriptor(
-      name='ABS_LOCK_TIME', index=4, number=4,
-      serialized_options=None,
-      type=None,
-      create_key=_descriptor._internal_create_key),
-  ],
-  containing_type=None,
-  serialized_options=None,
-  serialized_start=467,
-  serialized_end=580,
-)
-_sym_db.RegisterEnumDescriptor(_OFFERMESSAGE_LOCKTYPE)
-
-
-_OFFERMESSAGE = _descriptor.Descriptor(
-  name='OfferMessage',
-  full_name='basicswap.OfferMessage',
-  filename=None,
-  file=DESCRIPTOR,
-  containing_type=None,
-  create_key=_descriptor._internal_create_key,
-  fields=[
-    _descriptor.FieldDescriptor(
-      name='coin_from', full_name='basicswap.OfferMessage.coin_from', index=0,
-      number=1, type=13, cpp_type=3, label=1,
-      has_default_value=False, default_value=0,
-      message_type=None, enum_type=None, containing_type=None,
-      is_extension=False, extension_scope=None,
-      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
-    _descriptor.FieldDescriptor(
-      name='coin_to', full_name='basicswap.OfferMessage.coin_to', index=1,
-      number=2, type=13, cpp_type=3, label=1,
-      has_default_value=False, default_value=0,
-      message_type=None, enum_type=None, containing_type=None,
-      is_extension=False, extension_scope=None,
-      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
-    _descriptor.FieldDescriptor(
-      name='amount_from', full_name='basicswap.OfferMessage.amount_from', index=2,
-      number=3, type=4, cpp_type=4, label=1,
-      has_default_value=False, default_value=0,
-      message_type=None, enum_type=None, containing_type=None,
-      is_extension=False, extension_scope=None,
-      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
-    _descriptor.FieldDescriptor(
-      name='rate', full_name='basicswap.OfferMessage.rate', index=3,
-      number=4, type=4, cpp_type=4, label=1,
-      has_default_value=False, default_value=0,
-      message_type=None, enum_type=None, containing_type=None,
-      is_extension=False, extension_scope=None,
-      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
-    _descriptor.FieldDescriptor(
-      name='min_bid_amount', full_name='basicswap.OfferMessage.min_bid_amount', index=4,
-      number=5, type=4, cpp_type=4, label=1,
-      has_default_value=False, default_value=0,
-      message_type=None, enum_type=None, containing_type=None,
-      is_extension=False, extension_scope=None,
-      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
-    _descriptor.FieldDescriptor(
-      name='time_valid', full_name='basicswap.OfferMessage.time_valid', index=5,
-      number=6, type=4, cpp_type=4, label=1,
-      has_default_value=False, default_value=0,
-      message_type=None, enum_type=None, containing_type=None,
-      is_extension=False, extension_scope=None,
-      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
-    _descriptor.FieldDescriptor(
-      name='lock_type', full_name='basicswap.OfferMessage.lock_type', index=6,
-      number=7, type=14, cpp_type=8, label=1,
-      has_default_value=False, default_value=0,
-      message_type=None, enum_type=None, containing_type=None,
-      is_extension=False, extension_scope=None,
-      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
-    _descriptor.FieldDescriptor(
-      name='lock_value', full_name='basicswap.OfferMessage.lock_value', index=7,
-      number=8, type=13, cpp_type=3, label=1,
-      has_default_value=False, default_value=0,
-      message_type=None, enum_type=None, containing_type=None,
-      is_extension=False, extension_scope=None,
-      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
-    _descriptor.FieldDescriptor(
-      name='swap_type', full_name='basicswap.OfferMessage.swap_type', index=8,
-      number=9, type=13, cpp_type=3, label=1,
-      has_default_value=False, default_value=0,
-      message_type=None, enum_type=None, containing_type=None,
-      is_extension=False, extension_scope=None,
-      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
-    _descriptor.FieldDescriptor(
-      name='proof_address', full_name='basicswap.OfferMessage.proof_address', index=9,
-      number=10, type=9, cpp_type=9, label=1,
-      has_default_value=False, default_value=b"".decode('utf-8'),
-      message_type=None, enum_type=None, containing_type=None,
-      is_extension=False, extension_scope=None,
-      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
-    _descriptor.FieldDescriptor(
-      name='proof_signature', full_name='basicswap.OfferMessage.proof_signature', index=10,
-      number=11, type=9, cpp_type=9, label=1,
-      has_default_value=False, default_value=b"".decode('utf-8'),
-      message_type=None, enum_type=None, containing_type=None,
-      is_extension=False, extension_scope=None,
-      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
-    _descriptor.FieldDescriptor(
-      name='pkhash_seller', full_name='basicswap.OfferMessage.pkhash_seller', index=11,
-      number=12, type=12, cpp_type=9, label=1,
-      has_default_value=False, default_value=b"",
-      message_type=None, enum_type=None, containing_type=None,
-      is_extension=False, extension_scope=None,
-      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
-    _descriptor.FieldDescriptor(
-      name='secret_hash', full_name='basicswap.OfferMessage.secret_hash', index=12,
-      number=13, type=12, cpp_type=9, label=1,
-      has_default_value=False, default_value=b"",
-      message_type=None, enum_type=None, containing_type=None,
-      is_extension=False, extension_scope=None,
-      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
-    _descriptor.FieldDescriptor(
-      name='fee_rate_from', full_name='basicswap.OfferMessage.fee_rate_from', index=13,
-      number=14, type=4, cpp_type=4, label=1,
-      has_default_value=False, default_value=0,
-      message_type=None, enum_type=None, containing_type=None,
-      is_extension=False, extension_scope=None,
-      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
-    _descriptor.FieldDescriptor(
-      name='fee_rate_to', full_name='basicswap.OfferMessage.fee_rate_to', index=14,
-      number=15, type=4, cpp_type=4, label=1,
-      has_default_value=False, default_value=0,
-      message_type=None, enum_type=None, containing_type=None,
-      is_extension=False, extension_scope=None,
-      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
-    _descriptor.FieldDescriptor(
-      name='protocol_version', full_name='basicswap.OfferMessage.protocol_version', index=15,
-      number=16, type=13, cpp_type=3, label=1,
-      has_default_value=False, default_value=0,
-      message_type=None, enum_type=None, containing_type=None,
-      is_extension=False, extension_scope=None,
-      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
-    _descriptor.FieldDescriptor(
-      name='amount_negotiable', full_name='basicswap.OfferMessage.amount_negotiable', index=16,
-      number=17, type=8, cpp_type=7, label=1,
-      has_default_value=False, default_value=False,
-      message_type=None, enum_type=None, containing_type=None,
-      is_extension=False, extension_scope=None,
-      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
-    _descriptor.FieldDescriptor(
-      name='rate_negotiable', full_name='basicswap.OfferMessage.rate_negotiable', index=17,
-      number=18, type=8, cpp_type=7, label=1,
-      has_default_value=False, default_value=False,
-      message_type=None, enum_type=None, containing_type=None,
-      is_extension=False, extension_scope=None,
-      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
-  ],
-  extensions=[
-  ],
-  nested_types=[],
-  enum_types=[
-    _OFFERMESSAGE_LOCKTYPE,
-  ],
-  serialized_options=None,
-  is_extendable=False,
-  syntax='proto3',
-  extension_ranges=[],
-  oneofs=[
-  ],
-  serialized_start=30,
-  serialized_end=580,
-)
-
-
-_BIDMESSAGE = _descriptor.Descriptor(
-  name='BidMessage',
-  full_name='basicswap.BidMessage',
-  filename=None,
-  file=DESCRIPTOR,
-  containing_type=None,
-  create_key=_descriptor._internal_create_key,
-  fields=[
-    _descriptor.FieldDescriptor(
-      name='offer_msg_id', full_name='basicswap.BidMessage.offer_msg_id', index=0,
-      number=1, type=12, cpp_type=9, label=1,
-      has_default_value=False, default_value=b"",
-      message_type=None, enum_type=None, containing_type=None,
-      is_extension=False, extension_scope=None,
-      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
-    _descriptor.FieldDescriptor(
-      name='time_valid', full_name='basicswap.BidMessage.time_valid', index=1,
-      number=2, type=4, cpp_type=4, label=1,
-      has_default_value=False, default_value=0,
-      message_type=None, enum_type=None, containing_type=None,
-      is_extension=False, extension_scope=None,
-      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
-    _descriptor.FieldDescriptor(
-      name='amount', full_name='basicswap.BidMessage.amount', index=2,
-      number=3, type=4, cpp_type=4, label=1,
-      has_default_value=False, default_value=0,
-      message_type=None, enum_type=None, containing_type=None,
-      is_extension=False, extension_scope=None,
-      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
-    _descriptor.FieldDescriptor(
-      name='rate', full_name='basicswap.BidMessage.rate', index=3,
-      number=4, type=4, cpp_type=4, label=1,
-      has_default_value=False, default_value=0,
-      message_type=None, enum_type=None, containing_type=None,
-      is_extension=False, extension_scope=None,
-      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
-    _descriptor.FieldDescriptor(
-      name='pkhash_buyer', full_name='basicswap.BidMessage.pkhash_buyer', index=4,
-      number=5, type=12, cpp_type=9, label=1,
-      has_default_value=False, default_value=b"",
-      message_type=None, enum_type=None, containing_type=None,
-      is_extension=False, extension_scope=None,
-      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
-    _descriptor.FieldDescriptor(
-      name='proof_address', full_name='basicswap.BidMessage.proof_address', index=5,
-      number=6, type=9, cpp_type=9, label=1,
-      has_default_value=False, default_value=b"".decode('utf-8'),
-      message_type=None, enum_type=None, containing_type=None,
-      is_extension=False, extension_scope=None,
-      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
-    _descriptor.FieldDescriptor(
-      name='proof_signature', full_name='basicswap.BidMessage.proof_signature', index=6,
-      number=7, type=9, cpp_type=9, label=1,
-      has_default_value=False, default_value=b"".decode('utf-8'),
-      message_type=None, enum_type=None, containing_type=None,
-      is_extension=False, extension_scope=None,
-      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
-    _descriptor.FieldDescriptor(
-      name='protocol_version', full_name='basicswap.BidMessage.protocol_version', index=7,
-      number=8, type=13, cpp_type=3, label=1,
-      has_default_value=False, default_value=0,
-      message_type=None, enum_type=None, containing_type=None,
-      is_extension=False, extension_scope=None,
-      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
-  ],
-  extensions=[
-  ],
-  nested_types=[],
-  enum_types=[
-  ],
-  serialized_options=None,
-  is_extendable=False,
-  syntax='proto3',
-  extension_ranges=[],
-  oneofs=[
-  ],
-  serialized_start=583,
-  serialized_end=763,
-)
-
-
-_BIDACCEPTMESSAGE = _descriptor.Descriptor(
-  name='BidAcceptMessage',
-  full_name='basicswap.BidAcceptMessage',
-  filename=None,
-  file=DESCRIPTOR,
-  containing_type=None,
-  create_key=_descriptor._internal_create_key,
-  fields=[
-    _descriptor.FieldDescriptor(
-      name='bid_msg_id', full_name='basicswap.BidAcceptMessage.bid_msg_id', index=0,
-      number=1, type=12, cpp_type=9, label=1,
-      has_default_value=False, default_value=b"",
-      message_type=None, enum_type=None, containing_type=None,
-      is_extension=False, extension_scope=None,
-      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
-    _descriptor.FieldDescriptor(
-      name='initiate_txid', full_name='basicswap.BidAcceptMessage.initiate_txid', index=1,
-      number=2, type=12, cpp_type=9, label=1,
-      has_default_value=False, default_value=b"",
-      message_type=None, enum_type=None, containing_type=None,
-      is_extension=False, extension_scope=None,
-      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
-    _descriptor.FieldDescriptor(
-      name='contract_script', full_name='basicswap.BidAcceptMessage.contract_script', index=2,
-      number=3, type=12, cpp_type=9, label=1,
-      has_default_value=False, default_value=b"",
-      message_type=None, enum_type=None, containing_type=None,
-      is_extension=False, extension_scope=None,
-      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
-  ],
-  extensions=[
-  ],
-  nested_types=[],
-  enum_types=[
-  ],
-  serialized_options=None,
-  is_extendable=False,
-  syntax='proto3',
-  extension_ranges=[],
-  oneofs=[
-  ],
-  serialized_start=765,
-  serialized_end=851,
-)
-
-
-_OFFERREVOKEMESSAGE = _descriptor.Descriptor(
-  name='OfferRevokeMessage',
-  full_name='basicswap.OfferRevokeMessage',
-  filename=None,
-  file=DESCRIPTOR,
-  containing_type=None,
-  create_key=_descriptor._internal_create_key,
-  fields=[
-    _descriptor.FieldDescriptor(
-      name='offer_msg_id', full_name='basicswap.OfferRevokeMessage.offer_msg_id', index=0,
-      number=1, type=12, cpp_type=9, label=1,
-      has_default_value=False, default_value=b"",
-      message_type=None, enum_type=None, containing_type=None,
-      is_extension=False, extension_scope=None,
-      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
-    _descriptor.FieldDescriptor(
-      name='signature', full_name='basicswap.OfferRevokeMessage.signature', index=1,
-      number=2, type=12, cpp_type=9, label=1,
-      has_default_value=False, default_value=b"",
-      message_type=None, enum_type=None, containing_type=None,
-      is_extension=False, extension_scope=None,
-      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
-  ],
-  extensions=[
-  ],
-  nested_types=[],
-  enum_types=[
-  ],
-  serialized_options=None,
-  is_extendable=False,
-  syntax='proto3',
-  extension_ranges=[],
-  oneofs=[
-  ],
-  serialized_start=853,
-  serialized_end=914,
-)
-
-
-_BIDREJECTMESSAGE = _descriptor.Descriptor(
-  name='BidRejectMessage',
-  full_name='basicswap.BidRejectMessage',
-  filename=None,
-  file=DESCRIPTOR,
-  containing_type=None,
-  create_key=_descriptor._internal_create_key,
-  fields=[
-    _descriptor.FieldDescriptor(
-      name='bid_msg_id', full_name='basicswap.BidRejectMessage.bid_msg_id', index=0,
-      number=1, type=12, cpp_type=9, label=1,
-      has_default_value=False, default_value=b"",
-      message_type=None, enum_type=None, containing_type=None,
-      is_extension=False, extension_scope=None,
-      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
-    _descriptor.FieldDescriptor(
-      name='reject_code', full_name='basicswap.BidRejectMessage.reject_code', index=1,
-      number=2, type=13, cpp_type=3, label=1,
-      has_default_value=False, default_value=0,
-      message_type=None, enum_type=None, containing_type=None,
-      is_extension=False, extension_scope=None,
-      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
-  ],
-  extensions=[
-  ],
-  nested_types=[],
-  enum_types=[
-  ],
-  serialized_options=None,
-  is_extendable=False,
-  syntax='proto3',
-  extension_ranges=[],
-  oneofs=[
-  ],
-  serialized_start=916,
-  serialized_end=975,
-)
-
-
-_XMRBIDMESSAGE = _descriptor.Descriptor(
-  name='XmrBidMessage',
-  full_name='basicswap.XmrBidMessage',
-  filename=None,
-  file=DESCRIPTOR,
-  containing_type=None,
-  create_key=_descriptor._internal_create_key,
-  fields=[
-    _descriptor.FieldDescriptor(
-      name='offer_msg_id', full_name='basicswap.XmrBidMessage.offer_msg_id', index=0,
-      number=1, type=12, cpp_type=9, label=1,
-      has_default_value=False, default_value=b"",
-      message_type=None, enum_type=None, containing_type=None,
-      is_extension=False, extension_scope=None,
-      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
-    _descriptor.FieldDescriptor(
-      name='time_valid', full_name='basicswap.XmrBidMessage.time_valid', index=1,
-      number=2, type=4, cpp_type=4, label=1,
-      has_default_value=False, default_value=0,
-      message_type=None, enum_type=None, containing_type=None,
-      is_extension=False, extension_scope=None,
-      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
-    _descriptor.FieldDescriptor(
-      name='amount', full_name='basicswap.XmrBidMessage.amount', index=2,
-      number=3, type=4, cpp_type=4, label=1,
-      has_default_value=False, default_value=0,
-      message_type=None, enum_type=None, containing_type=None,
-      is_extension=False, extension_scope=None,
-      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
-    _descriptor.FieldDescriptor(
-      name='rate', full_name='basicswap.XmrBidMessage.rate', index=3,
-      number=4, type=4, cpp_type=4, label=1,
-      has_default_value=False, default_value=0,
-      message_type=None, enum_type=None, containing_type=None,
-      is_extension=False, extension_scope=None,
-      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
-    _descriptor.FieldDescriptor(
-      name='pkaf', full_name='basicswap.XmrBidMessage.pkaf', index=4,
-      number=5, type=12, cpp_type=9, label=1,
-      has_default_value=False, default_value=b"",
-      message_type=None, enum_type=None, containing_type=None,
-      is_extension=False, extension_scope=None,
-      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
-    _descriptor.FieldDescriptor(
-      name='kbvf', full_name='basicswap.XmrBidMessage.kbvf', index=5,
-      number=6, type=12, cpp_type=9, label=1,
-      has_default_value=False, default_value=b"",
-      message_type=None, enum_type=None, containing_type=None,
-      is_extension=False, extension_scope=None,
-      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
-    _descriptor.FieldDescriptor(
-      name='kbsf_dleag', full_name='basicswap.XmrBidMessage.kbsf_dleag', index=6,
-      number=7, type=12, cpp_type=9, label=1,
-      has_default_value=False, default_value=b"",
-      message_type=None, enum_type=None, containing_type=None,
-      is_extension=False, extension_scope=None,
-      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
-    _descriptor.FieldDescriptor(
-      name='dest_af', full_name='basicswap.XmrBidMessage.dest_af', index=7,
-      number=8, type=12, cpp_type=9, label=1,
-      has_default_value=False, default_value=b"",
-      message_type=None, enum_type=None, containing_type=None,
-      is_extension=False, extension_scope=None,
-      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
-    _descriptor.FieldDescriptor(
-      name='protocol_version', full_name='basicswap.XmrBidMessage.protocol_version', index=8,
-      number=9, type=13, cpp_type=3, label=1,
-      has_default_value=False, default_value=0,
-      message_type=None, enum_type=None, containing_type=None,
-      is_extension=False, extension_scope=None,
-      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
-  ],
-  extensions=[
-  ],
-  nested_types=[],
-  enum_types=[
-  ],
-  serialized_options=None,
-  is_extendable=False,
-  syntax='proto3',
-  extension_ranges=[],
-  oneofs=[
-  ],
-  serialized_start=978,
-  serialized_end=1156,
-)
-
-
-_XMRSPLITMESSAGE = _descriptor.Descriptor(
-  name='XmrSplitMessage',
-  full_name='basicswap.XmrSplitMessage',
-  filename=None,
-  file=DESCRIPTOR,
-  containing_type=None,
-  create_key=_descriptor._internal_create_key,
-  fields=[
-    _descriptor.FieldDescriptor(
-      name='msg_id', full_name='basicswap.XmrSplitMessage.msg_id', index=0,
-      number=1, type=12, cpp_type=9, label=1,
-      has_default_value=False, default_value=b"",
-      message_type=None, enum_type=None, containing_type=None,
-      is_extension=False, extension_scope=None,
-      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
-    _descriptor.FieldDescriptor(
-      name='msg_type', full_name='basicswap.XmrSplitMessage.msg_type', index=1,
-      number=2, type=13, cpp_type=3, label=1,
-      has_default_value=False, default_value=0,
-      message_type=None, enum_type=None, containing_type=None,
-      is_extension=False, extension_scope=None,
-      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
-    _descriptor.FieldDescriptor(
-      name='sequence', full_name='basicswap.XmrSplitMessage.sequence', index=2,
-      number=3, type=13, cpp_type=3, label=1,
-      has_default_value=False, default_value=0,
-      message_type=None, enum_type=None, containing_type=None,
-      is_extension=False, extension_scope=None,
-      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
-    _descriptor.FieldDescriptor(
-      name='dleag', full_name='basicswap.XmrSplitMessage.dleag', index=3,
-      number=4, type=12, cpp_type=9, label=1,
-      has_default_value=False, default_value=b"",
-      message_type=None, enum_type=None, containing_type=None,
-      is_extension=False, extension_scope=None,
-      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
-  ],
-  extensions=[
-  ],
-  nested_types=[],
-  enum_types=[
-  ],
-  serialized_options=None,
-  is_extendable=False,
-  syntax='proto3',
-  extension_ranges=[],
-  oneofs=[
-  ],
-  serialized_start=1158,
-  serialized_end=1242,
-)
-
-
-_XMRBIDACCEPTMESSAGE = _descriptor.Descriptor(
-  name='XmrBidAcceptMessage',
-  full_name='basicswap.XmrBidAcceptMessage',
-  filename=None,
-  file=DESCRIPTOR,
-  containing_type=None,
-  create_key=_descriptor._internal_create_key,
-  fields=[
-    _descriptor.FieldDescriptor(
-      name='bid_msg_id', full_name='basicswap.XmrBidAcceptMessage.bid_msg_id', index=0,
-      number=1, type=12, cpp_type=9, label=1,
-      has_default_value=False, default_value=b"",
-      message_type=None, enum_type=None, containing_type=None,
-      is_extension=False, extension_scope=None,
-      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
-    _descriptor.FieldDescriptor(
-      name='pkal', full_name='basicswap.XmrBidAcceptMessage.pkal', index=1,
-      number=3, type=12, cpp_type=9, label=1,
-      has_default_value=False, default_value=b"",
-      message_type=None, enum_type=None, containing_type=None,
-      is_extension=False, extension_scope=None,
-      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
-    _descriptor.FieldDescriptor(
-      name='kbvl', full_name='basicswap.XmrBidAcceptMessage.kbvl', index=2,
-      number=4, type=12, cpp_type=9, label=1,
-      has_default_value=False, default_value=b"",
-      message_type=None, enum_type=None, containing_type=None,
-      is_extension=False, extension_scope=None,
-      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
-    _descriptor.FieldDescriptor(
-      name='kbsl_dleag', full_name='basicswap.XmrBidAcceptMessage.kbsl_dleag', index=3,
-      number=5, type=12, cpp_type=9, label=1,
-      has_default_value=False, default_value=b"",
-      message_type=None, enum_type=None, containing_type=None,
-      is_extension=False, extension_scope=None,
-      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
-    _descriptor.FieldDescriptor(
-      name='a_lock_tx', full_name='basicswap.XmrBidAcceptMessage.a_lock_tx', index=4,
-      number=6, type=12, cpp_type=9, label=1,
-      has_default_value=False, default_value=b"",
-      message_type=None, enum_type=None, containing_type=None,
-      is_extension=False, extension_scope=None,
-      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
-    _descriptor.FieldDescriptor(
-      name='a_lock_tx_script', full_name='basicswap.XmrBidAcceptMessage.a_lock_tx_script', index=5,
-      number=7, type=12, cpp_type=9, label=1,
-      has_default_value=False, default_value=b"",
-      message_type=None, enum_type=None, containing_type=None,
-      is_extension=False, extension_scope=None,
-      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
-    _descriptor.FieldDescriptor(
-      name='a_lock_refund_tx', full_name='basicswap.XmrBidAcceptMessage.a_lock_refund_tx', index=6,
-      number=8, type=12, cpp_type=9, label=1,
-      has_default_value=False, default_value=b"",
-      message_type=None, enum_type=None, containing_type=None,
-      is_extension=False, extension_scope=None,
-      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
-    _descriptor.FieldDescriptor(
-      name='a_lock_refund_tx_script', full_name='basicswap.XmrBidAcceptMessage.a_lock_refund_tx_script', index=7,
-      number=9, type=12, cpp_type=9, label=1,
-      has_default_value=False, default_value=b"",
-      message_type=None, enum_type=None, containing_type=None,
-      is_extension=False, extension_scope=None,
-      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
-    _descriptor.FieldDescriptor(
-      name='a_lock_refund_spend_tx', full_name='basicswap.XmrBidAcceptMessage.a_lock_refund_spend_tx', index=8,
-      number=10, type=12, cpp_type=9, label=1,
-      has_default_value=False, default_value=b"",
-      message_type=None, enum_type=None, containing_type=None,
-      is_extension=False, extension_scope=None,
-      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
-    _descriptor.FieldDescriptor(
-      name='al_lock_refund_tx_sig', full_name='basicswap.XmrBidAcceptMessage.al_lock_refund_tx_sig', index=9,
-      number=11, type=12, cpp_type=9, label=1,
-      has_default_value=False, default_value=b"",
-      message_type=None, enum_type=None, containing_type=None,
-      is_extension=False, extension_scope=None,
-      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
-  ],
-  extensions=[
-  ],
-  nested_types=[],
-  enum_types=[
-  ],
-  serialized_options=None,
-  is_extendable=False,
-  syntax='proto3',
-  extension_ranges=[],
-  oneofs=[
-  ],
-  serialized_start=1245,
-  serialized_end=1501,
-)
-
-
-_XMRBIDLOCKTXSIGSMESSAGE = _descriptor.Descriptor(
-  name='XmrBidLockTxSigsMessage',
-  full_name='basicswap.XmrBidLockTxSigsMessage',
-  filename=None,
-  file=DESCRIPTOR,
-  containing_type=None,
-  create_key=_descriptor._internal_create_key,
-  fields=[
-    _descriptor.FieldDescriptor(
-      name='bid_msg_id', full_name='basicswap.XmrBidLockTxSigsMessage.bid_msg_id', index=0,
-      number=1, type=12, cpp_type=9, label=1,
-      has_default_value=False, default_value=b"",
-      message_type=None, enum_type=None, containing_type=None,
-      is_extension=False, extension_scope=None,
-      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
-    _descriptor.FieldDescriptor(
-      name='af_lock_refund_spend_tx_esig', full_name='basicswap.XmrBidLockTxSigsMessage.af_lock_refund_spend_tx_esig', index=1,
-      number=2, type=12, cpp_type=9, label=1,
-      has_default_value=False, default_value=b"",
-      message_type=None, enum_type=None, containing_type=None,
-      is_extension=False, extension_scope=None,
-      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
-    _descriptor.FieldDescriptor(
-      name='af_lock_refund_tx_sig', full_name='basicswap.XmrBidLockTxSigsMessage.af_lock_refund_tx_sig', index=2,
-      number=3, type=12, cpp_type=9, label=1,
-      has_default_value=False, default_value=b"",
-      message_type=None, enum_type=None, containing_type=None,
-      is_extension=False, extension_scope=None,
-      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
-  ],
-  extensions=[
-  ],
-  nested_types=[],
-  enum_types=[
-  ],
-  serialized_options=None,
-  is_extendable=False,
-  syntax='proto3',
-  extension_ranges=[],
-  oneofs=[
-  ],
-  serialized_start=1503,
-  serialized_end=1617,
-)
-
-
-_XMRBIDLOCKSPENDTXMESSAGE = _descriptor.Descriptor(
-  name='XmrBidLockSpendTxMessage',
-  full_name='basicswap.XmrBidLockSpendTxMessage',
-  filename=None,
-  file=DESCRIPTOR,
-  containing_type=None,
-  create_key=_descriptor._internal_create_key,
-  fields=[
-    _descriptor.FieldDescriptor(
-      name='bid_msg_id', full_name='basicswap.XmrBidLockSpendTxMessage.bid_msg_id', index=0,
-      number=1, type=12, cpp_type=9, label=1,
-      has_default_value=False, default_value=b"",
-      message_type=None, enum_type=None, containing_type=None,
-      is_extension=False, extension_scope=None,
-      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
-    _descriptor.FieldDescriptor(
-      name='a_lock_spend_tx', full_name='basicswap.XmrBidLockSpendTxMessage.a_lock_spend_tx', index=1,
-      number=2, type=12, cpp_type=9, label=1,
-      has_default_value=False, default_value=b"",
-      message_type=None, enum_type=None, containing_type=None,
-      is_extension=False, extension_scope=None,
-      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
-    _descriptor.FieldDescriptor(
-      name='kal_sig', full_name='basicswap.XmrBidLockSpendTxMessage.kal_sig', index=2,
-      number=3, type=12, cpp_type=9, label=1,
-      has_default_value=False, default_value=b"",
-      message_type=None, enum_type=None, containing_type=None,
-      is_extension=False, extension_scope=None,
-      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
-  ],
-  extensions=[
-  ],
-  nested_types=[],
-  enum_types=[
-  ],
-  serialized_options=None,
-  is_extendable=False,
-  syntax='proto3',
-  extension_ranges=[],
-  oneofs=[
-  ],
-  serialized_start=1619,
-  serialized_end=1707,
-)
-
-
-_XMRBIDLOCKRELEASEMESSAGE = _descriptor.Descriptor(
-  name='XmrBidLockReleaseMessage',
-  full_name='basicswap.XmrBidLockReleaseMessage',
-  filename=None,
-  file=DESCRIPTOR,
-  containing_type=None,
-  create_key=_descriptor._internal_create_key,
-  fields=[
-    _descriptor.FieldDescriptor(
-      name='bid_msg_id', full_name='basicswap.XmrBidLockReleaseMessage.bid_msg_id', index=0,
-      number=1, type=12, cpp_type=9, label=1,
-      has_default_value=False, default_value=b"",
-      message_type=None, enum_type=None, containing_type=None,
-      is_extension=False, extension_scope=None,
-      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
-    _descriptor.FieldDescriptor(
-      name='al_lock_spend_tx_esig', full_name='basicswap.XmrBidLockReleaseMessage.al_lock_spend_tx_esig', index=1,
-      number=2, type=12, cpp_type=9, label=1,
-      has_default_value=False, default_value=b"",
-      message_type=None, enum_type=None, containing_type=None,
-      is_extension=False, extension_scope=None,
-      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
-  ],
-  extensions=[
-  ],
-  nested_types=[],
-  enum_types=[
-  ],
-  serialized_options=None,
-  is_extendable=False,
-  syntax='proto3',
-  extension_ranges=[],
-  oneofs=[
-  ],
-  serialized_start=1709,
-  serialized_end=1786,
-)
-
-_OFFERMESSAGE.fields_by_name['lock_type'].enum_type = _OFFERMESSAGE_LOCKTYPE
-_OFFERMESSAGE_LOCKTYPE.containing_type = _OFFERMESSAGE
-DESCRIPTOR.message_types_by_name['OfferMessage'] = _OFFERMESSAGE
-DESCRIPTOR.message_types_by_name['BidMessage'] = _BIDMESSAGE
-DESCRIPTOR.message_types_by_name['BidAcceptMessage'] = _BIDACCEPTMESSAGE
-DESCRIPTOR.message_types_by_name['OfferRevokeMessage'] = _OFFERREVOKEMESSAGE
-DESCRIPTOR.message_types_by_name['BidRejectMessage'] = _BIDREJECTMESSAGE
-DESCRIPTOR.message_types_by_name['XmrBidMessage'] = _XMRBIDMESSAGE
-DESCRIPTOR.message_types_by_name['XmrSplitMessage'] = _XMRSPLITMESSAGE
-DESCRIPTOR.message_types_by_name['XmrBidAcceptMessage'] = _XMRBIDACCEPTMESSAGE
-DESCRIPTOR.message_types_by_name['XmrBidLockTxSigsMessage'] = _XMRBIDLOCKTXSIGSMESSAGE
-DESCRIPTOR.message_types_by_name['XmrBidLockSpendTxMessage'] = _XMRBIDLOCKSPENDTXMESSAGE
-DESCRIPTOR.message_types_by_name['XmrBidLockReleaseMessage'] = _XMRBIDLOCKRELEASEMESSAGE
-_sym_db.RegisterFileDescriptor(DESCRIPTOR)
-
-OfferMessage = _reflection.GeneratedProtocolMessageType('OfferMessage', (_message.Message,), {
-  'DESCRIPTOR' : _OFFERMESSAGE,
-  '__module__' : 'messages_pb2'
-  # @@protoc_insertion_point(class_scope:basicswap.OfferMessage)
-  })
-_sym_db.RegisterMessage(OfferMessage)
-
-BidMessage = _reflection.GeneratedProtocolMessageType('BidMessage', (_message.Message,), {
-  'DESCRIPTOR' : _BIDMESSAGE,
-  '__module__' : 'messages_pb2'
-  # @@protoc_insertion_point(class_scope:basicswap.BidMessage)
-  })
-_sym_db.RegisterMessage(BidMessage)
-
-BidAcceptMessage = _reflection.GeneratedProtocolMessageType('BidAcceptMessage', (_message.Message,), {
-  'DESCRIPTOR' : _BIDACCEPTMESSAGE,
-  '__module__' : 'messages_pb2'
-  # @@protoc_insertion_point(class_scope:basicswap.BidAcceptMessage)
-  })
-_sym_db.RegisterMessage(BidAcceptMessage)
-
-OfferRevokeMessage = _reflection.GeneratedProtocolMessageType('OfferRevokeMessage', (_message.Message,), {
-  'DESCRIPTOR' : _OFFERREVOKEMESSAGE,
-  '__module__' : 'messages_pb2'
-  # @@protoc_insertion_point(class_scope:basicswap.OfferRevokeMessage)
-  })
-_sym_db.RegisterMessage(OfferRevokeMessage)
-
-BidRejectMessage = _reflection.GeneratedProtocolMessageType('BidRejectMessage', (_message.Message,), {
-  'DESCRIPTOR' : _BIDREJECTMESSAGE,
-  '__module__' : 'messages_pb2'
-  # @@protoc_insertion_point(class_scope:basicswap.BidRejectMessage)
-  })
-_sym_db.RegisterMessage(BidRejectMessage)
-
-XmrBidMessage = _reflection.GeneratedProtocolMessageType('XmrBidMessage', (_message.Message,), {
-  'DESCRIPTOR' : _XMRBIDMESSAGE,
-  '__module__' : 'messages_pb2'
-  # @@protoc_insertion_point(class_scope:basicswap.XmrBidMessage)
-  })
-_sym_db.RegisterMessage(XmrBidMessage)
-
-XmrSplitMessage = _reflection.GeneratedProtocolMessageType('XmrSplitMessage', (_message.Message,), {
-  'DESCRIPTOR' : _XMRSPLITMESSAGE,
-  '__module__' : 'messages_pb2'
-  # @@protoc_insertion_point(class_scope:basicswap.XmrSplitMessage)
-  })
-_sym_db.RegisterMessage(XmrSplitMessage)
-
-XmrBidAcceptMessage = _reflection.GeneratedProtocolMessageType('XmrBidAcceptMessage', (_message.Message,), {
-  'DESCRIPTOR' : _XMRBIDACCEPTMESSAGE,
-  '__module__' : 'messages_pb2'
-  # @@protoc_insertion_point(class_scope:basicswap.XmrBidAcceptMessage)
-  })
-_sym_db.RegisterMessage(XmrBidAcceptMessage)
-
-XmrBidLockTxSigsMessage = _reflection.GeneratedProtocolMessageType('XmrBidLockTxSigsMessage', (_message.Message,), {
-  'DESCRIPTOR' : _XMRBIDLOCKTXSIGSMESSAGE,
-  '__module__' : 'messages_pb2'
-  # @@protoc_insertion_point(class_scope:basicswap.XmrBidLockTxSigsMessage)
-  })
-_sym_db.RegisterMessage(XmrBidLockTxSigsMessage)
-
-XmrBidLockSpendTxMessage = _reflection.GeneratedProtocolMessageType('XmrBidLockSpendTxMessage', (_message.Message,), {
-  'DESCRIPTOR' : _XMRBIDLOCKSPENDTXMESSAGE,
-  '__module__' : 'messages_pb2'
-  # @@protoc_insertion_point(class_scope:basicswap.XmrBidLockSpendTxMessage)
-  })
-_sym_db.RegisterMessage(XmrBidLockSpendTxMessage)
-
-XmrBidLockReleaseMessage = _reflection.GeneratedProtocolMessageType('XmrBidLockReleaseMessage', (_message.Message,), {
-  'DESCRIPTOR' : _XMRBIDLOCKRELEASEMESSAGE,
-  '__module__' : 'messages_pb2'
-  # @@protoc_insertion_point(class_scope:basicswap.XmrBidLockReleaseMessage)
-  })
-_sym_db.RegisterMessage(XmrBidLockReleaseMessage)
-
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x0emessages.proto\x12\tbasicswap\"\xa6\x04\n\x0cOfferMessage\x12\x11\n\tcoin_from\x18\x01 \x01(\r\x12\x0f\n\x07\x63oin_to\x18\x02 \x01(\r\x12\x13\n\x0b\x61mount_from\x18\x03 \x01(\x04\x12\x0c\n\x04rate\x18\x04 \x01(\x04\x12\x16\n\x0emin_bid_amount\x18\x05 \x01(\x04\x12\x12\n\ntime_valid\x18\x06 \x01(\x04\x12\x33\n\tlock_type\x18\x07 \x01(\x0e\x32 .basicswap.OfferMessage.LockType\x12\x12\n\nlock_value\x18\x08 \x01(\r\x12\x11\n\tswap_type\x18\t \x01(\r\x12\x15\n\rproof_address\x18\n \x01(\t\x12\x17\n\x0fproof_signature\x18\x0b \x01(\t\x12\x15\n\rpkhash_seller\x18\x0c \x01(\x0c\x12\x13\n\x0bsecret_hash\x18\r \x01(\x0c\x12\x15\n\rfee_rate_from\x18\x0e \x01(\x04\x12\x13\n\x0b\x66\x65\x65_rate_to\x18\x0f \x01(\x04\x12\x18\n\x10protocol_version\x18\x10 \x01(\r\x12\x19\n\x11\x61mount_negotiable\x18\x11 \x01(\x08\x12\x17\n\x0frate_negotiable\x18\x12 \x01(\x08\"q\n\x08LockType\x12\x0b\n\x07NOT_SET\x10\x00\x12\x18\n\x14SEQUENCE_LOCK_BLOCKS\x10\x01\x12\x16\n\x12SEQUENCE_LOCK_TIME\x10\x02\x12\x13\n\x0f\x41\x42S_LOCK_BLOCKS\x10\x03\x12\x11\n\rABS_LOCK_TIME\x10\x04\"\xc9\x01\n\nBidMessage\x12\x14\n\x0coffer_msg_id\x18\x01 \x01(\x0c\x12\x12\n\ntime_valid\x18\x02 \x01(\x04\x12\x0e\n\x06\x61mount\x18\x03 \x01(\x04\x12\x0c\n\x04rate\x18\x04 \x01(\x04\x12\x14\n\x0cpkhash_buyer\x18\x05 \x01(\x0c\x12\x15\n\rproof_address\x18\x06 \x01(\t\x12\x17\n\x0fproof_signature\x18\x07 \x01(\t\x12\x18\n\x10protocol_version\x18\x08 \x01(\r\x12\x13\n\x0bproof_utxos\x18\t \x01(\x0c\"\xc1\x01\n\x17\x42idMessage_v1Deprecated\x12\x14\n\x0coffer_msg_id\x18\x01 \x01(\x0c\x12\x12\n\ntime_valid\x18\x02 \x01(\x04\x12\x0e\n\x06\x61mount\x18\x03 \x01(\x04\x12\x0c\n\x04rate\x18\x04 \x01(\x04\x12\x14\n\x0cpkhash_buyer\x18\x05 \x01(\x0c\x12\x15\n\rproof_address\x18\x06 \x01(\t\x12\x17\n\x0fproof_signature\x18\x07 \x01(\t\x12\x18\n\x10protocol_version\x18\x08 \x01(\r\"V\n\x10\x42idAcceptMessage\x12\x12\n\nbid_msg_id\x18\x01 \x01(\x0c\x12\x15\n\rinitiate_txid\x18\x02 \x01(\x0c\x12\x17\n\x0f\x63ontract_script\x18\x03 \x01(\x0c\"=\n\x12OfferRevokeMessage\x12\x14\n\x0coffer_msg_id\x18\x01 \x01(\x0c\x12\x11\n\tsignature\x18\x02 \x01(\x0c\";\n\x10\x42idRejectMessage\x12\x12\n\nbid_msg_id\x18\x01 \x01(\x0c\x12\x13\n\x0breject_code\x18\x02 \x01(\r\"\xb2\x01\n\rXmrBidMessage\x12\x14\n\x0coffer_msg_id\x18\x01 \x01(\x0c\x12\x12\n\ntime_valid\x18\x02 \x01(\x04\x12\x0e\n\x06\x61mount\x18\x03 \x01(\x04\x12\x0c\n\x04rate\x18\x04 \x01(\x04\x12\x0c\n\x04pkaf\x18\x05 \x01(\x0c\x12\x0c\n\x04kbvf\x18\x06 \x01(\x0c\x12\x12\n\nkbsf_dleag\x18\x07 \x01(\x0c\x12\x0f\n\x07\x64\x65st_af\x18\x08 \x01(\x0c\x12\x18\n\x10protocol_version\x18\t \x01(\r\"T\n\x0fXmrSplitMessage\x12\x0e\n\x06msg_id\x18\x01 \x01(\x0c\x12\x10\n\x08msg_type\x18\x02 \x01(\r\x12\x10\n\x08sequence\x18\x03 \x01(\r\x12\r\n\x05\x64leag\x18\x04 \x01(\x0c\"\x80\x02\n\x13XmrBidAcceptMessage\x12\x12\n\nbid_msg_id\x18\x01 \x01(\x0c\x12\x0c\n\x04pkal\x18\x03 \x01(\x0c\x12\x0c\n\x04kbvl\x18\x04 \x01(\x0c\x12\x12\n\nkbsl_dleag\x18\x05 \x01(\x0c\x12\x11\n\ta_lock_tx\x18\x06 \x01(\x0c\x12\x18\n\x10\x61_lock_tx_script\x18\x07 \x01(\x0c\x12\x18\n\x10\x61_lock_refund_tx\x18\x08 \x01(\x0c\x12\x1f\n\x17\x61_lock_refund_tx_script\x18\t \x01(\x0c\x12\x1e\n\x16\x61_lock_refund_spend_tx\x18\n \x01(\x0c\x12\x1d\n\x15\x61l_lock_refund_tx_sig\x18\x0b \x01(\x0c\"r\n\x17XmrBidLockTxSigsMessage\x12\x12\n\nbid_msg_id\x18\x01 \x01(\x0c\x12$\n\x1c\x61\x66_lock_refund_spend_tx_esig\x18\x02 \x01(\x0c\x12\x1d\n\x15\x61\x66_lock_refund_tx_sig\x18\x03 \x01(\x0c\"X\n\x18XmrBidLockSpendTxMessage\x12\x12\n\nbid_msg_id\x18\x01 \x01(\x0c\x12\x17\n\x0f\x61_lock_spend_tx\x18\x02 \x01(\x0c\x12\x0f\n\x07kal_sig\x18\x03 \x01(\x0c\"M\n\x18XmrBidLockReleaseMessage\x12\x12\n\nbid_msg_id\x18\x01 \x01(\x0c\x12\x1d\n\x15\x61l_lock_spend_tx_esig\x18\x02 \x01(\x0c\"\x8f\x01\n\x13\x41\x44SBidIntentMessage\x12\x14\n\x0coffer_msg_id\x18\x01 \x01(\x0c\x12\x12\n\ntime_valid\x18\x02 \x01(\x04\x12\x13\n\x0b\x61mount_from\x18\x03 \x01(\x04\x12\x11\n\tamount_to\x18\x04 \x01(\x04\x12\x0c\n\x04rate\x18\x05 \x01(\x04\x12\x18\n\x10protocol_version\x18\x06 \x01(\r\"p\n\x19\x41\x44SBidIntentAcceptMessage\x12\x12\n\nbid_msg_id\x18\x01 \x01(\x0c\x12\x0c\n\x04pkaf\x18\x02 \x01(\x0c\x12\x0c\n\x04kbvf\x18\x03 \x01(\x0c\x12\x12\n\nkbsf_dleag\x18\x04 \x01(\x0c\x12\x0f\n\x07\x64\x65st_af\x18\x05 \x01(\x0c\x62\x06proto3')
 
+_globals = globals()
+_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals)
+_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'messages_pb2', _globals)
+if _descriptor._USE_C_DESCRIPTORS == False:
+  DESCRIPTOR._options = None
+  _globals['_OFFERMESSAGE']._serialized_start=30
+  _globals['_OFFERMESSAGE']._serialized_end=580
+  _globals['_OFFERMESSAGE_LOCKTYPE']._serialized_start=467
+  _globals['_OFFERMESSAGE_LOCKTYPE']._serialized_end=580
+  _globals['_BIDMESSAGE']._serialized_start=583
+  _globals['_BIDMESSAGE']._serialized_end=784
+  _globals['_BIDMESSAGE_V1DEPRECATED']._serialized_start=787
+  _globals['_BIDMESSAGE_V1DEPRECATED']._serialized_end=980
+  _globals['_BIDACCEPTMESSAGE']._serialized_start=982
+  _globals['_BIDACCEPTMESSAGE']._serialized_end=1068
+  _globals['_OFFERREVOKEMESSAGE']._serialized_start=1070
+  _globals['_OFFERREVOKEMESSAGE']._serialized_end=1131
+  _globals['_BIDREJECTMESSAGE']._serialized_start=1133
+  _globals['_BIDREJECTMESSAGE']._serialized_end=1192
+  _globals['_XMRBIDMESSAGE']._serialized_start=1195
+  _globals['_XMRBIDMESSAGE']._serialized_end=1373
+  _globals['_XMRSPLITMESSAGE']._serialized_start=1375
+  _globals['_XMRSPLITMESSAGE']._serialized_end=1459
+  _globals['_XMRBIDACCEPTMESSAGE']._serialized_start=1462
+  _globals['_XMRBIDACCEPTMESSAGE']._serialized_end=1718
+  _globals['_XMRBIDLOCKTXSIGSMESSAGE']._serialized_start=1720
+  _globals['_XMRBIDLOCKTXSIGSMESSAGE']._serialized_end=1834
+  _globals['_XMRBIDLOCKSPENDTXMESSAGE']._serialized_start=1836
+  _globals['_XMRBIDLOCKSPENDTXMESSAGE']._serialized_end=1924
+  _globals['_XMRBIDLOCKRELEASEMESSAGE']._serialized_start=1926
+  _globals['_XMRBIDLOCKRELEASEMESSAGE']._serialized_end=2003
+  _globals['_ADSBIDINTENTMESSAGE']._serialized_start=2006
+  _globals['_ADSBIDINTENTMESSAGE']._serialized_end=2149
+  _globals['_ADSBIDINTENTACCEPTMESSAGE']._serialized_start=2151
+  _globals['_ADSBIDINTENTACCEPTMESSAGE']._serialized_end=2263
 # @@protoc_insertion_point(module_scope)

basicswap/network.py

@@ -24,7 +24,6 @@ import queue
 import random
 import select
 import socket
-import struct
 import hashlib
 import logging
 import secrets
@@ -41,7 +40,7 @@ from basicswap.contrib.rfc6979 import (
 
 
 START_TOKEN = 0xabcd
-MSG_START_TOKEN = struct.pack('>H', START_TOKEN)
+MSG_START_TOKEN = START_TOKEN.to_bytes(2, 'big')
 
 MSG_MAX_SIZE = 0x200000  # 2MB
 
@@ -83,8 +82,8 @@ class MsgHandshake:
         pass
 
     def encode_aad(self):  # Additional Authenticated Data
-        return struct.pack('>H', NetMessageTypes.HANDSHAKE) + \
-            struct.pack('>Q', self._timestamp) + \
+        return int(NetMessageTypes.HANDSHAKE).to_bytes(2, 'big') + \
+            self._timestamp.to_bytes(8, 'big') + \
             self._ephem_pk
 
     def encode(self):
@@ -92,7 +91,7 @@ class MsgHandshake:
 
     def decode(self, msg_mv):
         o = 2
-        self._timestamp = struct.unpack('>Q', msg_mv[o: o + 8])[0]
+        self._timestamp = int.from_bytes(msg_mv[o: o + 8], 'big')
         o += 8
         self._ephem_pk = bytes(msg_mv[o: o + 33])
         o += 33
@@ -333,7 +332,7 @@ class Network:
 
             ss = k.ecdh(peer._pubkey)
 
-            hashed = hashlib.sha512(ss + struct.pack('>Q', msg._timestamp)).digest()
+            hashed = hashlib.sha512(ss + msg._timestamp.to_bytes(8, 'big')).digest()
             peer._ke = hashed[:32]
             peer._km = hashed[32:]
 
@@ -386,7 +385,7 @@ class Network:
             nk = PrivateKey(self._network_key)
             ss = nk.ecdh(msg._ephem_pk)
 
-            hashed = hashlib.sha512(ss + struct.pack('>Q', msg._timestamp)).digest()
+            hashed = hashlib.sha512(ss + msg._timestamp.to_bytes(8, 'big')).digest()
             peer._ke = hashed[:32]
             peer._km = hashed[32:]
 
@@ -427,7 +426,7 @@ class Network:
         mac = msg_mv[-16:]
         plaintext = cipher.decrypt_and_verify(msg_mv[2: -16], mac)
 
-        ping_nonce = struct.unpack('>I', plaintext[:4])[0]
+        ping_nonce = int.from_bytes(plaintext[:4], 'big')
         # Version is added to a ping following a handshake message
         if len(plaintext) >= 10:
             peer._ready = True
@@ -450,7 +449,7 @@ class Network:
         mac = msg_mv[-16:]
         plaintext = cipher.decrypt_and_verify(msg_mv[2: -16], mac)
 
-        pong_nonce = struct.unpack('>I', plaintext[:4])[0]
+        pong_nonce = int.from_bytes(plaintext[:4], 'big')
 
         if pong_nonce == peer._ping_nonce:
             peer._last_ping_rtt = (time.time_ns() // 1000) - peer._last_ping_at
@@ -462,14 +461,14 @@ class Network:
     def send_ping(self, peer):
         ping_nonce = random.getrandbits(32)
 
-        msg_bytes = struct.pack('>H', NetMessageTypes.PING)
+        msg_bytes = int(NetMessageTypes.PING).to_bytes(2, 'big')
         nonce = peer._sent_nonce[:24]
 
         cipher = ChaCha20_Poly1305.new(key=peer._ke, nonce=nonce)
         cipher.update(msg_bytes)
         cipher.update(nonce)
 
-        payload = struct.pack('>I', ping_nonce)
+        payload = ping_nonce.to_bytes(4, 'big')
         if peer._last_ping_at == 0:
             payload += self._sc._version
         ct, mac = cipher.encrypt_and_digest(payload)
@@ -484,14 +483,14 @@ class Network:
         self.send_msg(peer, msg_bytes)
 
     def send_pong(self, peer, ping_nonce):
-        msg_bytes = struct.pack('>H', NetMessageTypes.PONG)
+        msg_bytes = int(NetMessageTypes.PONG).to_bytes(2, 'big')
         nonce = peer._sent_nonce[:24]
 
         cipher = ChaCha20_Poly1305.new(key=peer._ke, nonce=nonce)
         cipher.update(msg_bytes)
         cipher.update(nonce)
 
-        payload = struct.pack('>I', ping_nonce)
+        payload = ping_nonce.to_bytes(4, 'big')
         ct, mac = cipher.encrypt_and_digest(payload)
         msg_bytes += ct + mac
 
@@ -503,7 +502,7 @@ class Network:
         msg_encoded = msg if isinstance(msg, bytes) else msg.encode()
         len_encoded = len(msg_encoded)
 
-        msg_packed = bytearray(MSG_START_TOKEN) + struct.pack('>I', len_encoded) + msg_encoded
+        msg_packed = bytearray(MSG_START_TOKEN) + len_encoded.to_bytes(4, 'big') + msg_encoded
         peer._socket.sendall(msg_packed)
 
         peer._bytes_sent += len_encoded
@@ -515,7 +514,7 @@ class Network:
         try:
             mv = memoryview(msg_bytes)
             o = 0
-            msg_type = struct.unpack('>H', mv[o: o + 2])[0]
+            msg_type = int.from_bytes(mv[o: o + 2], 'big')
             if msg_type == NetMessageTypes.HANDSHAKE:
                 self.process_handshake(peer, mv)
             elif msg_type == NetMessageTypes.PING:
@@ -548,13 +547,13 @@ class Network:
                         raise ValueError('Invalid start token')
                     o += 2
 
-                    msg_len = struct.unpack('>I', mv[o: o + 4])[0]
+                    msg_len = int.from_bytes(mv[o: o + 4], 'big')
                     o += 4
                     if msg_len < 2 or msg_len > MSG_MAX_SIZE:
                         raise ValueError('Invalid data length')
 
                     # Precheck msg_type
-                    msg_type = struct.unpack('>H', mv[o: o + 2])[0]
+                    msg_type = int.from_bytes(mv[o: o + 2], 'big')
                     # o += 2  # Don't inc offset, msg includes type
                     if not NetMessageTypes.has_value(msg_type):
                         raise ValueError('Invalid msg type')

basicswap/protocols/__init__.py

@@ -0,0 +1,35 @@
+# -*- coding: utf-8 -*-
+
+# Copyright (c) 2022-2023 tecnovert
+# Distributed under the MIT software license, see the accompanying
+# file LICENSE or http://www.opensource.org/licenses/mit-license.php.
+
+from basicswap.script import (
+    OpCodes,
+)
+from basicswap.interface.btc import (
+    find_vout_for_address_from_txobj,
+)
+
+
+class ProtocolInterface:
+    swap_type = None
+
+    def getFundedInitiateTxTemplate(self, ci, amount: int, sub_fee: bool) -> bytes:
+        raise ValueError('base class')
+
+    def getMockScript(self) -> bytearray:
+        return bytearray([
+            OpCodes.OP_RETURN, OpCodes.OP_1])
+
+    def getMockScriptScriptPubkey(self, ci) -> bytearray:
+        script = self.getMockScript()
+        return ci.getScriptDest(script) if ci._use_segwit else ci.get_p2sh_script_pubkey(script)
+
+    def getMockAddrTo(self, ci):
+        script = self.getMockScript()
+        return ci.encodeScriptDest(ci.getScriptDest(script)) if ci._use_segwit else ci.encode_p2sh(script)
+
+    def findMockVout(self, ci, itx_decoded):
+        mock_addr = self.getMockAddrTo(ci)
+        return find_vout_for_address_from_txobj(itx_decoded, mock_addr)

basicswap/protocols/atomic_swap_1.py

@@ -1,21 +1,29 @@
 # -*- coding: utf-8 -*-
 
-# Copyright (c) 2020 tecnovert
+# Copyright (c) 2020-2023 tecnovert
 # Distributed under the MIT software license, see the accompanying
 # file LICENSE or http://www.opensource.org/licenses/mit-license.php.
 
+from basicswap.db import (
+    Concepts,
+)
 from basicswap.util import (
     SerialiseNum,
 )
 from basicswap.script import (
     OpCodes,
 )
-
+from basicswap.basicswap_util import (
+    SwapTypes,
+    EventLogTypes,
+)
+from . import ProtocolInterface
 
 INITIATE_TX_TIMEOUT = 40 * 60  # TODO: make variable per coin
+ABS_LOCK_TIME_LEEWAY = 10 * 60
 
 
-def buildContractScript(lock_val, secret_hash, pkh_redeem, pkh_refund, op_lock=OpCodes.OP_CHECKSEQUENCEVERIFY):
+def buildContractScript(lock_val: int, secret_hash: bytes, pkh_redeem: bytes, pkh_refund: bytes, op_lock=OpCodes.OP_CHECKSEQUENCEVERIFY) -> bytearray:
     script = bytearray([
         OpCodes.OP_IF,
         OpCodes.OP_SIZE,
@@ -48,3 +56,45 @@ def buildContractScript(lock_val, secret_hash, pkh_redeem, pkh_refund, op_lock=O
 
 def extractScriptSecretHash(script):
     return script[7:39]
+
+
+def redeemITx(self, bid_id: bytes, session):
+    bid, offer = self.getBidAndOffer(bid_id, session)
+    ci_from = self.ci(offer.coin_from)
+
+    txn = self.createRedeemTxn(ci_from.coin_type(), bid, for_txn_type='initiate')
+    txid = ci_from.publishTx(bytes.fromhex(txn))
+
+    bid.initiate_tx.spend_txid = bytes.fromhex(txid)
+    self.log.debug('Submitted initiate redeem txn %s to %s chain for bid %s', txid, ci_from.coin_name(), bid_id.hex())
+    self.logEvent(Concepts.BID, bid_id, EventLogTypes.ITX_REDEEM_PUBLISHED, '', session)
+
+
+class AtomicSwapInterface(ProtocolInterface):
+    swap_type = SwapTypes.SELLER_FIRST
+
+    def getFundedInitiateTxTemplate(self, ci, amount: int, sub_fee: bool) -> bytes:
+        addr_to = self.getMockAddrTo(ci)
+        funded_tx = ci.createRawFundedTransaction(addr_to, amount, sub_fee, lock_unspents=False)
+
+        return bytes.fromhex(funded_tx)
+
+    def promoteMockTx(self, ci, mock_tx: bytes, script: bytearray) -> bytearray:
+        mock_txo_script = self.getMockScriptScriptPubkey(ci)
+        real_txo_script = ci.getScriptDest(script) if ci._use_segwit else ci.get_p2sh_script_pubkey(script)
+
+        found: int = 0
+        ctx = ci.loadTx(mock_tx)
+        for txo in ctx.vout:
+            if txo.scriptPubKey == mock_txo_script:
+                txo.scriptPubKey = real_txo_script
+                found += 1
+
+        if found < 1:
+            raise ValueError('Mocked output not found')
+        if found > 1:
+            raise ValueError('Too many mocked outputs found')
+        ctx.nLockTime = 0
+
+        funded_tx = ctx.serialize()
+        return ci.signTxWithWallet(funded_tx)

basicswap/protocols/xmr_swap_1.py

@@ -1,6 +1,6 @@
 # -*- coding: utf-8 -*-
 
-# Copyright (c) 2020 tecnovert
+# Copyright (c) 2020-2023 tecnovert
 # Distributed under the MIT software license, see the accompanying
 # file LICENSE or http://www.opensource.org/licenses/mit-license.php.
 
@@ -9,13 +9,19 @@ from sqlalchemy.orm import scoped_session
 from basicswap.util import (
     ensure,
 )
+from basicswap.interface import Curves
 from basicswap.chainparams import (
     Coins,
 )
 from basicswap.basicswap_util import (
     KeyTypes,
+    SwapTypes,
     EventLogTypes,
 )
+from . import ProtocolInterface
+from basicswap.contrib.test_framework.script import (
+    CScript, CScriptOp,
+    OP_CHECKMULTISIG)
 
 
 def addLockRefundSigs(self, xmr_swap, ci):
@@ -32,26 +38,32 @@ def addLockRefundSigs(self, xmr_swap, ci):
     xmr_swap.a_lock_refund_tx = signed_tx
 
 
-def recoverNoScriptTxnWithKey(self, bid_id, encoded_key):
+def recoverNoScriptTxnWithKey(self, bid_id: bytes, encoded_key):
     self.log.info('Manually recovering %s', bid_id.hex())
     # Manually recover txn if other key is known
     session = scoped_session(self.session_factory)
     try:
         bid, xmr_swap = self.getXmrBidFromSession(session, bid_id)
         ensure(bid, 'Bid not found: {}.'.format(bid_id.hex()))
-        ensure(xmr_swap, 'XMR swap not found: {}.'.format(bid_id.hex()))
+        ensure(xmr_swap, 'Adaptor-sig swap not found: {}.'.format(bid_id.hex()))
         offer, xmr_offer = self.getXmrOfferFromSession(session, bid.offer_id, sent=False)
         ensure(offer, 'Offer not found: {}.'.format(bid.offer_id.hex()))
-        ensure(xmr_offer, 'XMR offer not found: {}.'.format(bid.offer_id.hex()))
+        ensure(xmr_offer, 'Adaptor-sig offer not found: {}.'.format(bid.offer_id.hex()))
         ci_to = self.ci(offer.coin_to)
 
         for_ed25519 = True if Coins(offer.coin_to) == Coins.XMR else False
+
+        try:
+            decoded_key_half = ci_to.decodeKey(encoded_key)
+        except Exception as e:
+            raise ValueError('Failed to decode provided key-half: ', str(e))
+
         if bid.was_sent:
-            kbsl = ci_to.decodeKey(encoded_key)
+            kbsl = decoded_key_half
             kbsf = self.getPathKey(offer.coin_from, offer.coin_to, bid.created_at, xmr_swap.contract_count, KeyTypes.KBSF, for_ed25519)
         else:
             kbsl = self.getPathKey(offer.coin_from, offer.coin_to, bid.created_at, xmr_swap.contract_count, KeyTypes.KBSL, for_ed25519)
-            kbsf = ci_to.decodeKey(encoded_key)
+            kbsf = decoded_key_half
         ensure(ci_to.verifyKey(kbsl), 'Invalid kbsl')
         ensure(ci_to.verifyKey(kbsf), 'Invalid kbsf')
         vkbs = ci_to.sumKeys(kbsl, kbsf)
@@ -74,7 +86,78 @@ def recoverNoScriptTxnWithKey(self, bid_id, encoded_key):
 
 
 def getChainBSplitKey(swap_client, bid, xmr_swap, offer):
-    ci_to = swap_client.ci(offer.coin_to)
+    reverse_bid: bool = offer.bid_reversed
+    ci_follower = swap_client.ci(offer.coin_from if reverse_bid else offer.coin_to)
 
     key_type = KeyTypes.KBSF if bid.was_sent else KeyTypes.KBSL
-    return ci_to.encodeKey(swap_client.getPathKey(offer.coin_from, offer.coin_to, bid.created_at, xmr_swap.contract_count, key_type, True if offer.coin_to == Coins.XMR else False))
+    return ci_follower.encodeKey(swap_client.getPathKey(offer.coin_from, offer.coin_to, bid.created_at, xmr_swap.contract_count, key_type, True if ci_follower.coin_type() == Coins.XMR else False))
+
+
+def getChainBRemoteSplitKey(swap_client, bid, xmr_swap, offer):
+    reverse_bid: bool = offer.bid_reversed
+    ci_leader = swap_client.ci(offer.coin_to if reverse_bid else offer.coin_from)
+    ci_follower = swap_client.ci(offer.coin_from if reverse_bid else offer.coin_to)
+
+    if bid.was_sent:
+        if xmr_swap.a_lock_refund_spend_tx:
+            af_lock_refund_spend_tx_sig = ci_leader.extractFollowerSig(xmr_swap.a_lock_refund_spend_tx)
+            kbsl = ci_leader.recoverEncKey(xmr_swap.af_lock_refund_spend_tx_esig, af_lock_refund_spend_tx_sig, xmr_swap.pkasl)
+            return ci_follower.encodeKey(kbsl)
+    else:
+        if xmr_swap.a_lock_spend_tx:
+            al_lock_spend_tx_sig = ci_leader.extractLeaderSig(xmr_swap.a_lock_spend_tx)
+            kbsf = ci_leader.recoverEncKey(xmr_swap.al_lock_spend_tx_esig, al_lock_spend_tx_sig, xmr_swap.pkasf)
+            return ci_follower.encodeKey(kbsf)
+    return None
+
+
+def setDLEAG(xmr_swap, ci_to, kbsf: bytes) -> None:
+    if ci_to.curve_type() == Curves.ed25519:
+        xmr_swap.kbsf_dleag = ci_to.proveDLEAG(kbsf)
+        xmr_swap.pkasf = xmr_swap.kbsf_dleag[0: 33]
+    elif ci_to.curve_type() == Curves.secp256k1:
+        for i in range(10):
+            xmr_swap.kbsf_dleag = ci_to.signRecoverable(kbsf, 'proof kbsf owned for swap')
+            pk_recovered: bytes = ci_to.verifySigAndRecover(xmr_swap.kbsf_dleag, 'proof kbsf owned for swap')
+            if pk_recovered == xmr_swap.pkbsf:
+                break
+            # self.log.debug('kbsl recovered pubkey mismatch, retrying.')
+        assert (pk_recovered == xmr_swap.pkbsf)
+        xmr_swap.pkasf = xmr_swap.pkbsf
+    else:
+        raise ValueError('Unknown curve')
+
+
+class XmrSwapInterface(ProtocolInterface):
+    swap_type = SwapTypes.XMR_SWAP
+
+    def genScriptLockTxScript(self, ci, Kal: bytes, Kaf: bytes) -> CScript:
+        Kal_enc = Kal if len(Kal) == 33 else ci.encodePubkey(Kal)
+        Kaf_enc = Kaf if len(Kaf) == 33 else ci.encodePubkey(Kaf)
+
+        return CScript([2, Kal_enc, Kaf_enc, 2, CScriptOp(OP_CHECKMULTISIG)])
+
+    def getFundedInitiateTxTemplate(self, ci, amount: int, sub_fee: bool) -> bytes:
+        addr_to = self.getMockAddrTo(ci)
+        funded_tx = ci.createRawFundedTransaction(addr_to, amount, sub_fee, lock_unspents=False)
+
+        return bytes.fromhex(funded_tx)
+
+    def promoteMockTx(self, ci, mock_tx: bytes, script: bytearray) -> bytearray:
+        mock_txo_script = self.getMockScriptScriptPubkey(ci)
+        real_txo_script = ci.getScriptDest(script)
+
+        found: int = 0
+        ctx = ci.loadTx(mock_tx)
+        for txo in ctx.vout:
+            if txo.scriptPubKey == mock_txo_script:
+                txo.scriptPubKey = real_txo_script
+                found += 1
+
+        if found < 1:
+            raise ValueError('Mocked output not found')
+        if found > 1:
+            raise ValueError('Too many mocked outputs found')
+        ctx.nLockTime = 0
+
+        return ctx.serialize()

basicswap/rpc.py

@@ -1,12 +1,13 @@
 # -*- coding: utf-8 -*-
 
-# Copyright (c) 2020 tecnovert
+# Copyright (c) 2020-2023 tecnovert
 # Distributed under the MIT software license, see the accompanying
 # file LICENSE or http://www.opensource.org/licenses/mit-license.php.
 
 import os
 import time
 import json
+import shlex
 import urllib
 import logging
 import traceback
@@ -19,10 +20,10 @@ from xmlrpc.client import (
 from .util import jsonDecimal
 
 
-def waitForRPC(rpc_func, wallet=None, max_tries=7):
+def waitForRPC(rpc_func, expect_wallet=True, max_tries=7):
     for i in range(max_tries + 1):
         try:
-            rpc_func('getwalletinfo')
+            rpc_func('getwalletinfo' if expect_wallet else 'getblockchaininfo')
             return
         except Exception as ex:
             if i < max_tries:
@@ -107,7 +108,7 @@ def callrpc(rpc_port, auth, method, params=[], wallet=None, host='127.0.0.1'):
         r = json.loads(v.decode('utf-8'))
     except Exception as ex:
         traceback.print_exc()
-        raise ValueError('RPC server error ' + str(ex))
+        raise ValueError('RPC server error ' + str(ex) + ', method: ' + method)
 
     if 'error' in r and r['error'] is not None:
         raise ValueError('RPC error ' + str(r['error']))
@@ -126,11 +127,18 @@ def openrpc(rpc_port, auth, wallet=None, host='127.0.0.1'):
         raise ValueError('RPC error ' + str(ex))
 
 
-def callrpc_cli(bindir, datadir, chain, cmd, cli_bin='particl-cli'):
+def callrpc_cli(bindir, datadir, chain, cmd, cli_bin='particl-cli', wallet=None):
     cli_bin = os.path.join(bindir, cli_bin)
 
-    args = cli_bin + ('' if chain == 'mainnet' else (' -' + chain)) + ' -datadir=' + datadir + ' ' + cmd
-    p = subprocess.Popen(args, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True)
+    args = [cli_bin, ]
+    if chain != 'mainnet':
+        args.append('-' + chain)
+    args.append('-datadir=' + datadir)
+    if wallet is not None:
+        args.append('-rpcwallet=' + wallet)
+    args += shlex.split(cmd)
+
+    p = subprocess.Popen(args, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
     out = p.communicate()
 
     if len(out[1]) > 0:
@@ -154,3 +162,9 @@ def make_rpc_func(port, auth, wallet=None, host='127.0.0.1'):
         nonlocal port, auth, wallet, host
         return callrpc(port, auth, method, params, wallet if wallet_override is None else wallet_override, host)
     return rpc_func
+
+
+def escape_rpcauth(auth_str: str) -> str:
+    username, password = auth_str.split(':', 1)
+    password = urllib.parse.quote(password, safe='')
+    return f'{username}:{password}'

basicswap/rpc_xmr.py

@@ -2,6 +2,7 @@
 
 import os
 import json
+import socks
 import time
 import urllib
 import hashlib
@@ -10,9 +11,32 @@ from xmlrpc.client import (
     Transport,
     SafeTransport,
 )
+from sockshandler import SocksiPyConnection
 from .util import jsonDecimal
 
 
+class SocksTransport(Transport):
+
+    def set_proxy(self, proxy_host, proxy_port):
+        self.proxy_host = proxy_host
+        self.proxy_port = proxy_port
+
+        self.proxy_type = socks.PROXY_TYPE_SOCKS5
+        self.proxy_rdns = True
+        self.proxy_username = None
+        self.proxy_password = None
+
+    def make_connection(self, host):
+        # return an existing connection if possible.  This allows
+        # HTTP/1.1 keep-alive.
+        if self._connection and host == self._connection[0]:
+            return self._connection[1]
+        # create a HTTP connection object from a host descriptor
+        chost, self._extra_headers, x509 = self.get_host_info(host)
+        self._connection = host, SocksiPyConnection(self.proxy_type, self.proxy_host, self.proxy_port, self.proxy_rdns, self.proxy_username, self.proxy_password, chost)
+        return self._connection[1]
+
+
 class JsonrpcDigest():
     # __getattr__ complicates extending ServerProxy
     def __init__(self, uri, transport=None, encoding=None, verbose=False,
@@ -37,12 +61,15 @@ class JsonrpcDigest():
         self.__verbose = verbose
         self.__allow_none = allow_none
 
-        self.__request_id = 1
+        self.__request_id = 0
 
     def close(self):
         if self.__transport is not None:
             self.__transport.close()
 
+    def request_id(self):
+        return self.__request_id
+
     def post_request(self, method, params, timeout=None):
         try:
             connection = self.__transport.make_connection(self.__host)
@@ -66,7 +93,7 @@ class JsonrpcDigest():
             self.__transport.close()
             raise
 
-    def json_request(self, method, params, username='', password='', timeout=None):
+    def json_request(self, request_body, username='', password='', timeout=None):
         try:
             connection = self.__transport.make_connection(self.__host)
             if timeout:
@@ -74,18 +101,11 @@ class JsonrpcDigest():
 
             headers = self.__transport._extra_headers[:]
 
-            request_body = {
-                'method': method,
-                'params': params,
-                'jsonrpc': '2.0',
-                'id': self.__request_id
-            }
-
             connection.putrequest('POST', self.__handler)
             headers.append(('Content-Type', 'application/json'))
             headers.append(('Connection', 'keep-alive'))
             self.__transport.send_headers(connection, headers)
-            self.__transport.send_content(connection, json.dumps(request_body, default=jsonDecimal).encode('utf-8'))
+            self.__transport.send_content(connection, json.dumps(request_body, default=jsonDecimal).encode('utf-8') if request_body else '')
             resp = connection.getresponse()
 
             if resp.status == 401:
@@ -135,18 +155,11 @@ class JsonrpcDigest():
                 headers = self.__transport._extra_headers[:]
                 headers.append(('Authorization', header_value))
 
-                request_body = {
-                    'method': method,
-                    'params': params,
-                    'jsonrpc': '2.0',
-                    'id': self.__request_id
-                }
-
                 connection.putrequest('POST', self.__handler)
                 headers.append(('Content-Type', 'application/json'))
                 headers.append(('Connection', 'keep-alive'))
                 self.__transport.send_headers(connection, headers)
-                self.__transport.send_content(connection, json.dumps(request_body, default=jsonDecimal).encode('utf-8'))
+                self.__transport.send_content(connection, json.dumps(request_body, default=jsonDecimal).encode('utf-8') if request_body else '')
                 resp = connection.getresponse()
 
             self.__request_id += 1
@@ -159,7 +172,7 @@ class JsonrpcDigest():
             raise
 
 
-def callrpc_xmr(rpc_port, auth, method, params=[], rpc_host='127.0.0.1', path='json_rpc', timeout=120):
+def callrpc_xmr(rpc_port, method, params=[], rpc_host='127.0.0.1', path='json_rpc', auth=None, timeout=120, transport=None, tag=''):
     # auth is a tuple: (username, password)
     try:
         if rpc_host.count('://') > 0:
@@ -167,84 +180,79 @@ def callrpc_xmr(rpc_port, auth, method, params=[], rpc_host='127.0.0.1', path='j
         else:
             url = 'http://{}:{}/{}'.format(rpc_host, rpc_port, path)
 
-        x = JsonrpcDigest(url)
-        v = x.json_request(method, params, username=auth[0], password=auth[1], timeout=timeout)
-        x.close()
-        r = json.loads(v.decode('utf-8'))
-    except Exception as ex:
-        raise ValueError('RPC Server Error: {}'.format(str(ex)))
-
-    if 'error' in r and r['error'] is not None:
-        raise ValueError('RPC error ' + str(r['error']))
-
-    return r['result']
-
-
-def callrpc_xmr_na(rpc_port, method, params=[], rpc_host='127.0.0.1', path='json_rpc', timeout=120):
-    try:
-        if rpc_host.count('://') > 0:
-            url = '{}:{}/{}'.format(rpc_host, rpc_port, path)
+        x = JsonrpcDigest(url, transport=transport)
+        request_body = {
+            'method': method,
+            'params': params,
+            'jsonrpc': '2.0',
+            'id': x.request_id()
+        }
+        if auth:
+            v = x.json_request(request_body, username=auth[0], password=auth[1], timeout=timeout)
         else:
-            url = 'http://{}:{}/{}'.format(rpc_host, rpc_port, path)
-
-        x = JsonrpcDigest(url)
-        v = x.json_request(method, params, timeout=timeout)
+            v = x.json_request(request_body, timeout=timeout)
         x.close()
         r = json.loads(v.decode('utf-8'))
     except Exception as ex:
-        raise ValueError('RPC Server Error: {}'.format(str(ex)))
+        raise ValueError('{}RPC Server Error: {}'.format(tag, str(ex)))
 
     if 'error' in r and r['error'] is not None:
-        raise ValueError('RPC error ' + str(r['error']))
+        raise ValueError(tag + 'RPC error ' + str(r['error']))
 
     return r['result']
 
 
-def callrpc_xmr2(rpc_port, method, params=None, rpc_host='127.0.0.1', timeout=120):
+def callrpc_xmr2(rpc_port: int, method: str, params=None, auth=None, rpc_host='127.0.0.1', timeout=120, transport=None, tag=''):
     try:
         if rpc_host.count('://') > 0:
             url = '{}:{}/{}'.format(rpc_host, rpc_port, method)
         else:
             url = 'http://{}:{}/{}'.format(rpc_host, rpc_port, method)
 
-        x = JsonrpcDigest(url)
-        v = x.post_request(method, params, timeout=timeout)
+        x = JsonrpcDigest(url, transport=transport)
+        if auth:
+            v = x.json_request(params, username=auth[0], password=auth[1], timeout=timeout)
+        else:
+            v = x.json_request(params, timeout=timeout)
         x.close()
         r = json.loads(v.decode('utf-8'))
     except Exception as ex:
-        raise ValueError('RPC Server Error: {}'.format(str(ex)))
+        raise ValueError('{}RPC Server Error: {}'.format(tag, str(ex)))
 
     return r
 
 
-def make_xmr_rpc_func(port, host='127.0.0.1'):
-    port = port
-    host = host
-
-    def rpc_func(method, params=None, wallet=None, timeout=120):
-        nonlocal port
-        nonlocal host
-        return callrpc_xmr_na(port, method, params, rpc_host=host, timeout=timeout)
-    return rpc_func
-
-
-def make_xmr_rpc2_func(port, host='127.0.0.1'):
-    port = port
-    host = host
-
-    def rpc_func(method, params=None, wallet=None, timeout=120):
-        nonlocal port
-        nonlocal host
-        return callrpc_xmr2(port, method, params, rpc_host=host, timeout=timeout)
-    return rpc_func
-
-
-def make_xmr_wallet_rpc_func(port, auth, host='127.0.0.1'):
+def make_xmr_rpc2_func(port, auth, host='127.0.0.1', proxy_host=None, proxy_port=None, default_timeout=120, tag=''):
     port = port
     auth = auth
     host = host
+    transport = None
+    default_timeout = default_timeout
+    tag = tag
 
-    def rpc_func(method, params=None, wallet=None, timeout=120):
-        nonlocal port, auth, host
-        return callrpc_xmr(port, auth, method, params, rpc_host=host, timeout=timeout)
+    if proxy_host:
+        transport = SocksTransport()
+        transport.set_proxy(proxy_host, proxy_port)
+
+    def rpc_func(method, params=None, wallet=None, timeout=default_timeout):
+        nonlocal port, auth, host, transport, tag
+        return callrpc_xmr2(port, method, params, auth=auth, rpc_host=host, timeout=timeout, transport=transport, tag=tag)
+    return rpc_func
+
+
+def make_xmr_rpc_func(port, auth, host='127.0.0.1', proxy_host=None, proxy_port=None, default_timeout=120, tag=''):
+    port = port
+    auth = auth
+    host = host
+    transport = None
+    default_timeout = default_timeout
+    tag = tag
+
+    if proxy_host:
+        transport = SocksTransport()
+        transport.set_proxy(proxy_host, proxy_port)
+
+    def rpc_func(method, params=None, wallet=None, timeout=default_timeout):
+        nonlocal port, auth, host, transport, tag
+        return callrpc_xmr(port, method, params, rpc_host=host, auth=auth, timeout=timeout, transport=transport, tag=tag)
     return rpc_func

basicswap/script.py

@@ -1,6 +1,6 @@
 # -*- coding: utf-8 -*-
 
-# Copyright (c) 2019 tecnovert
+# Copyright (c) 2019-2022 tecnovert
 # Distributed under the MIT software license, see the accompanying
 # file LICENSE or http://www.opensource.org/licenses/mit-license.php.
 
@@ -15,6 +15,7 @@ class OpCodes(IntEnum):
     OP_IF = 0x63,
     OP_ELSE = 0x67,
     OP_ENDIF = 0x68,
+    OP_RETURN = 0x6a,
     OP_DROP = 0x75,
     OP_DUP = 0x76,
     OP_SIZE = 0x82,

basicswap/static/css/style.css

@@ -0,0 +1,141 @@
+
+.padded_row td
+{
+  padding-top:1.5em;
+}
+
+.bold
+{
+  font-weight:bold;
+}
+
+.monospace
+{
+  font-family:monospace;
+}
+
+.floatright
+{
+  position: fixed;
+  top:1.25rem;
+  right:1.25rem;
+  z-index: 9999;
+}
+
+.error_msg
+{
+  color:red;
+}
+
+#hide {
+    -moz-animation: cssAnimation 0s ease-in 15s forwards;
+    /* Firefox */
+    -webkit-animation: cssAnimation 0s ease-in 15s forwards;
+    /* Safari and Chrome */
+    -o-animation: cssAnimation 0s ease-in 15s forwards;
+    /* Opera */
+    animation: cssAnimation 0s ease-in 15s forwards;
+    -webkit-animation-fill-mode: forwards;
+    animation-fill-mode: forwards;
+}
+@keyframes cssAnimation {
+    to {
+        width:0;
+        height:0;
+        overflow:hidden;
+    }
+}
+@-webkit-keyframes cssAnimation {
+    to {
+        width:0;
+        height:0;
+        visibility:hidden;
+    }
+}
+
+.custom-select .select {
+    appearance: none;
+    background-image: url('/static/images/other/coin.png');
+    background-position: 10px center;
+    background-repeat: no-repeat;
+    position: relative;
+  }
+
+.custom-select select::-webkit-scrollbar {
+  width: 0;
+}
+
+.custom-select .select option {
+  padding-left: 0;
+  text-indent: 0;
+  background-repeat: no-repeat;
+  background-position: 0 50%;
+}
+
+.custom-select .select option.no-space {
+  padding-left: 0;
+}
+
+.custom-select .select option[data-image] {
+  background-image: url('');
+}
+
+.custom-select .select-icon {
+  position: absolute;
+  top: 50%;
+  left: 10px;
+  transform: translateY(-50%);
+}
+
+.custom-select .select-image {
+  display: none;
+  margin-top: 10px;
+}
+
+.custom-select .select:focus + .select-dropdown .select-image {
+  display: block;
+}
+
+.blurred {
+    filter: blur(4px);
+    pointer-events: none;
+    user-select: none; 
+}
+
+.error-overlay.non-blurred {
+    filter: none;
+    pointer-events: auto;
+    user-select: auto;
+}
+
+/* Disable opacity on disabled form elements in Chrome */
+@media screen and (-webkit-min-device-pixel-ratio:0) {
+  select:disabled,
+  input:disabled,
+  textarea:disabled {
+    opacity: 1 !important;
+  }
+}
+
+/* Add this to your existing CSS file */
+.error {
+  border: 1px solid red !important;
+}
+
+.active-container {
+  position: relative;
+  border-radius: 5px;
+}
+
+.active-container::before {
+  content: "";
+  position: absolute;
+  top: 0;
+  left: 0;
+  right: 0;
+  bottom: 0;
+  border: 1px solid rgb(77, 132, 240);
+  border-radius: inherit;
+  pointer-events: none;
+}
+