1451 lines
56 KiB
Python
1451 lines
56 KiB
Python
#!/usr/bin/env python
|
|
# -*- coding: utf-8 -*-
|
|
|
|
# Copyright (c) 2024 tecnovert
|
|
# Distributed under the MIT software license, see the accompanying
|
|
# file LICENSE or http://www.opensource.org/licenses/mit-license.php.
|
|
|
|
import base64
|
|
import hashlib
|
|
import json
|
|
import logging
|
|
import random
|
|
import traceback
|
|
|
|
from basicswap.basicswap_util import (
|
|
getVoutByScriptPubKey,
|
|
TxLockTypes
|
|
)
|
|
from basicswap.chainparams import Coins
|
|
from basicswap.contrib.test_framework.script import (
|
|
CScriptNum,
|
|
)
|
|
from basicswap.interface.base import (
|
|
Secp256k1Interface,
|
|
)
|
|
from basicswap.interface.btc import (
|
|
extractScriptLockScriptValues,
|
|
extractScriptLockRefundScriptValues,
|
|
)
|
|
from basicswap.util import (
|
|
ensure,
|
|
b2h, b2i, i2b, i2h,
|
|
)
|
|
from basicswap.util.address import (
|
|
b58decode,
|
|
b58encode,
|
|
)
|
|
from basicswap.util.crypto import (
|
|
blake256,
|
|
hash160,
|
|
ripemd160,
|
|
)
|
|
from basicswap.util.script import (
|
|
SerialiseNumCompact,
|
|
)
|
|
from basicswap.util.extkey import ExtKeyPair
|
|
from basicswap.util.integer import encode_varint
|
|
from basicswap.interface.dcr.rpc import make_rpc_func, openrpc
|
|
from .messages import (
|
|
COutPoint,
|
|
CTransaction,
|
|
CTxIn,
|
|
CTxOut,
|
|
findOutput,
|
|
SigHashType,
|
|
TxSerializeType,
|
|
)
|
|
from .script import (
|
|
OP_CHECKMULTISIG,
|
|
OP_CHECKSEQUENCEVERIFY,
|
|
OP_CHECKSIG,
|
|
OP_DROP,
|
|
OP_DUP,
|
|
OP_ELSE,
|
|
OP_ENDIF,
|
|
OP_EQUAL,
|
|
OP_EQUALVERIFY,
|
|
OP_HASH160,
|
|
OP_IF,
|
|
push_script_data,
|
|
)
|
|
from coincurve.keys import (
|
|
PrivateKey,
|
|
PublicKey,
|
|
)
|
|
from coincurve.ecdsaotves import (
|
|
ecdsaotves_enc_sign,
|
|
ecdsaotves_enc_verify,
|
|
ecdsaotves_dec_sig,
|
|
ecdsaotves_rec_enc_key
|
|
)
|
|
|
|
|
|
SEQUENCE_LOCKTIME_GRANULARITY = 9 # 512 seconds
|
|
SEQUENCE_LOCKTIME_TYPE_FLAG = (1 << 22)
|
|
SEQUENCE_LOCKTIME_MASK = 0x0000f
|
|
|
|
SigHashSerializePrefix: int = 1
|
|
SigHashSerializeWitness: int = 3
|
|
|
|
|
|
def DCRSignatureHash(sign_script: bytes, hash_type: SigHashType, tx: CTransaction, idx: int) -> bytes:
|
|
masked_hash_type = hash_type & SigHashType.SigHashMask
|
|
if masked_hash_type != SigHashType.SigHashAll:
|
|
raise ValueError('todo')
|
|
|
|
# Prefix hash
|
|
sign_tx_in_idx: int = idx
|
|
sign_vins = tx.vin
|
|
if hash_type & SigHashType.SigHashAnyOneCanPay != 0:
|
|
sign_vins = [tx.vin[idx],]
|
|
sign_tx_in_idx = 0
|
|
|
|
hash_buffer = bytearray()
|
|
version: int = tx.version | (SigHashSerializePrefix << 16)
|
|
hash_buffer += version.to_bytes(4, 'little')
|
|
hash_buffer += encode_varint(len(sign_vins))
|
|
|
|
for txi_n, txi in enumerate(sign_vins):
|
|
hash_buffer += txi.prevout.hash.to_bytes(32, 'little')
|
|
hash_buffer += txi.prevout.n.to_bytes(4, 'little')
|
|
hash_buffer += txi.prevout.tree.to_bytes(1, 'little')
|
|
|
|
# In the case of SigHashNone and SigHashSingle, commit to 0 for everything that is not the input being signed instead.
|
|
if (masked_hash_type == SigHashType.SigHashNone
|
|
or masked_hash_type == SigHashType.SigHashSingle) and \
|
|
sign_tx_in_idx != txi_n:
|
|
hash_buffer += (0).to_bytes(4, 'little')
|
|
else:
|
|
hash_buffer += txi.sequence.to_bytes(4, 'little')
|
|
|
|
hash_buffer += encode_varint(len(tx.vout))
|
|
|
|
for txo_n, txo in enumerate(tx.vout):
|
|
if masked_hash_type == SigHashType.SigHashSingle and \
|
|
idx != txo_n:
|
|
hash_buffer += (-1).to_bytes(8, 'little')
|
|
hash_buffer += txo.version.to_bytes(2, 'little')
|
|
hash_buffer += encode_varint(0)
|
|
continue
|
|
hash_buffer += txo.value.to_bytes(8, 'little')
|
|
hash_buffer += txo.version.to_bytes(2, 'little')
|
|
hash_buffer += encode_varint(len(txo.script_pubkey))
|
|
hash_buffer += txo.script_pubkey
|
|
|
|
hash_buffer += tx.locktime.to_bytes(4, 'little')
|
|
hash_buffer += tx.expiry.to_bytes(4, 'little')
|
|
|
|
prefix_hash = blake256(hash_buffer)
|
|
|
|
# Witness hash
|
|
hash_buffer.clear()
|
|
|
|
version: int = tx.version | (SigHashSerializeWitness << 16)
|
|
hash_buffer += version.to_bytes(4, 'little')
|
|
|
|
hash_buffer += encode_varint(len(sign_vins))
|
|
for txi_n, txi in enumerate(sign_vins):
|
|
if sign_tx_in_idx != txi_n:
|
|
hash_buffer += encode_varint(0)
|
|
continue
|
|
hash_buffer += encode_varint(len(sign_script))
|
|
hash_buffer += sign_script
|
|
|
|
witness_hash = blake256(hash_buffer)
|
|
|
|
hash_buffer.clear()
|
|
hash_buffer += hash_type.to_bytes(4, 'little')
|
|
hash_buffer += prefix_hash
|
|
hash_buffer += witness_hash
|
|
|
|
return blake256(hash_buffer)
|
|
|
|
|
|
def extract_sig_and_pk(sig_script: bytes) -> (bytes, bytes):
|
|
sig = None
|
|
pk = None
|
|
o: int = 0
|
|
num_bytes = sig_script[o]
|
|
o += 1
|
|
sig = sig_script[o: o + num_bytes]
|
|
o += num_bytes
|
|
num_bytes = sig_script[o]
|
|
o += 1
|
|
pk = sig_script[o: o + num_bytes]
|
|
return sig, pk
|
|
|
|
|
|
class DCRInterface(Secp256k1Interface):
|
|
|
|
@staticmethod
|
|
def coin_type():
|
|
return Coins.DCR
|
|
|
|
@staticmethod
|
|
def exp() -> int:
|
|
return 8
|
|
|
|
@staticmethod
|
|
def COIN() -> int:
|
|
return 100000000
|
|
|
|
@staticmethod
|
|
def nbk() -> int:
|
|
return 32
|
|
|
|
@staticmethod
|
|
def nbK() -> int: # No. of bytes requires to encode a public key
|
|
return 33
|
|
|
|
@staticmethod
|
|
def txVersion() -> int:
|
|
return 2
|
|
|
|
@staticmethod
|
|
def txoType():
|
|
return CTxOut
|
|
|
|
@staticmethod
|
|
def xmr_swap_a_lock_spend_tx_vsize() -> int:
|
|
return 327
|
|
|
|
@staticmethod
|
|
def xmr_swap_b_lock_spend_tx_vsize() -> int:
|
|
return 224
|
|
|
|
@staticmethod
|
|
def getExpectedSequence(lockType: int, lockVal: int) -> int:
|
|
ensure(lockVal >= 1, 'Bad lockVal')
|
|
if lockType == TxLockTypes.SEQUENCE_LOCK_BLOCKS:
|
|
return lockVal
|
|
if lockType == TxLockTypes.SEQUENCE_LOCK_TIME:
|
|
secondsLocked = lockVal
|
|
# Ensure the locked time is never less than lockVal
|
|
if secondsLocked % (1 << SEQUENCE_LOCKTIME_GRANULARITY) != 0:
|
|
secondsLocked += (1 << SEQUENCE_LOCKTIME_GRANULARITY)
|
|
secondsLocked >>= SEQUENCE_LOCKTIME_GRANULARITY
|
|
return secondsLocked | SEQUENCE_LOCKTIME_TYPE_FLAG
|
|
raise ValueError('Unknown lock type')
|
|
|
|
@staticmethod
|
|
def decodeSequence(lock_value: int) -> int:
|
|
# Return the raw value
|
|
if lock_value & SEQUENCE_LOCKTIME_TYPE_FLAG:
|
|
return (lock_value & SEQUENCE_LOCKTIME_MASK) << SEQUENCE_LOCKTIME_GRANULARITY
|
|
return lock_value & SEQUENCE_LOCKTIME_MASK
|
|
|
|
@staticmethod
|
|
def watch_blocks_for_scripts() -> bool:
|
|
return True
|
|
|
|
@staticmethod
|
|
def depth_spendable() -> int:
|
|
return 0
|
|
|
|
def __init__(self, coin_settings, network, swap_client=None):
|
|
super().__init__(network)
|
|
self._rpc_host = coin_settings.get('rpchost', '127.0.0.1')
|
|
self._rpcport = coin_settings['rpcport']
|
|
self._rpcauth = coin_settings['rpcauth']
|
|
self._sc = swap_client
|
|
self._log = self._sc.log if self._sc and self._sc.log else logging
|
|
self.rpc = make_rpc_func(self._rpcport, self._rpcauth, host=self._rpc_host)
|
|
if 'walletrpcport' in coin_settings:
|
|
self._walletrpcport = coin_settings['walletrpcport']
|
|
self.rpc_wallet = make_rpc_func(self._walletrpcport, self._rpcauth, host=self._rpc_host)
|
|
else:
|
|
self._walletrpcport = None
|
|
self.rpc_wallet = None
|
|
self.blocks_confirmed = coin_settings['blocks_confirmed']
|
|
self.setConfTarget(coin_settings['conf_target'])
|
|
|
|
self._use_segwit = True # Decred is natively segwit
|
|
self._connection_type = coin_settings['connection_type']
|
|
|
|
def open_rpc(self):
|
|
return openrpc(self._rpcport, self._rpcauth, host=self._rpc_host)
|
|
|
|
def json_request(self, rpc_conn, method, params):
|
|
try:
|
|
v = rpc_conn.json_request(method, params)
|
|
r = json.loads(v.decode('utf-8'))
|
|
except Exception as ex:
|
|
traceback.print_exc()
|
|
raise ValueError('RPC Server Error ' + str(ex))
|
|
if 'error' in r and r['error'] is not None:
|
|
raise ValueError('RPC error ' + str(r['error']))
|
|
return r['result']
|
|
|
|
def close_rpc(self, rpc_conn):
|
|
rpc_conn.close()
|
|
|
|
def use_tx_vsize(self) -> bool:
|
|
return False
|
|
|
|
def pkh(self, pubkey: bytes) -> bytes:
|
|
return ripemd160(blake256(pubkey))
|
|
|
|
def pkh_to_address(self, pkh: bytes) -> str:
|
|
prefix = self.chainparams_network()['pubkey_address']
|
|
|
|
data = prefix.to_bytes(2, 'big') + pkh
|
|
checksum = blake256(blake256(data))
|
|
return b58encode(data + checksum[0:4])
|
|
|
|
def sh_to_address(self, sh: bytes) -> str:
|
|
assert (len(sh) == 20)
|
|
prefix = self.chainparams_network()['script_address']
|
|
data = prefix.to_bytes(2, 'big') + sh
|
|
checksum = blake256(blake256(data))
|
|
return b58encode(data + checksum[0:4])
|
|
|
|
def decode_address(self, address: str) -> bytes:
|
|
# Different from decodeAddress returns more prefix bytes
|
|
addr_data = b58decode(address)
|
|
if addr_data is None:
|
|
return None
|
|
prefixed_data = addr_data[:-4]
|
|
checksum = addr_data[-4:]
|
|
if blake256(blake256(prefixed_data))[:4] != checksum:
|
|
raise ValueError('Checksum mismatch')
|
|
return prefixed_data
|
|
|
|
def decodeAddress(self, address: str) -> bytes:
|
|
return self.decode_address(address)[2:]
|
|
|
|
def testDaemonRPC(self, with_wallet=True) -> None:
|
|
if with_wallet:
|
|
self.rpc_wallet('getinfo')
|
|
else:
|
|
self.rpc('getblockchaininfo')
|
|
|
|
def getChainHeight(self) -> int:
|
|
return self.rpc('getblockcount')
|
|
|
|
def initialiseWallet(self, key: bytes) -> None:
|
|
# Load with --create
|
|
pass
|
|
|
|
def isWalletEncrypted(self) -> bool:
|
|
return True
|
|
|
|
def isWalletLocked(self) -> bool:
|
|
walletislocked = self.rpc_wallet('walletislocked')
|
|
return walletislocked
|
|
|
|
def isWalletEncryptedLocked(self) -> (bool, bool):
|
|
walletislocked = self.rpc_wallet('walletislocked')
|
|
return True, walletislocked
|
|
|
|
def changeWalletPassword(self, old_password: str, new_password: str):
|
|
self._log.info('changeWalletPassword - {}'.format(self.ticker()))
|
|
if old_password == '':
|
|
# Read initial pwd from settings
|
|
settings = self._sc.getChainClientSettings(self.coin_type())
|
|
old_password = settings['wallet_pwd']
|
|
self.rpc_wallet('walletpassphrasechange', [old_password, new_password])
|
|
|
|
# Lock wallet to match other coins
|
|
self.rpc_wallet('walletlock')
|
|
|
|
# Clear initial password
|
|
self._sc.editSettings(self.coin_name().lower(), {'wallet_pwd': ''})
|
|
|
|
def unlockWallet(self, password: str):
|
|
if password == '':
|
|
return
|
|
self._log.info('unlockWallet - {}'.format(self.ticker()))
|
|
|
|
# Max timeout value, ~3 years
|
|
self.rpc_wallet('walletpassphrase', [password, 100000000])
|
|
self._sc.checkWalletSeed(self.coin_type())
|
|
|
|
def lockWallet(self):
|
|
self._log.info('lockWallet - {}'.format(self.ticker()))
|
|
self.rpc_wallet('walletlock')
|
|
|
|
def getWalletSeedID(self):
|
|
masterpubkey = self.rpc_wallet('getmasterpubkey')
|
|
masterpubkey_data = self.decode_address(masterpubkey)[4:]
|
|
return hash160(masterpubkey_data).hex()
|
|
|
|
def checkExpectedSeed(self, expect_seedid) -> bool:
|
|
self._expect_seedid_hex = expect_seedid
|
|
return expect_seedid == self.getWalletSeedID()
|
|
|
|
def getDaemonVersion(self):
|
|
return self.rpc('getnetworkinfo')['version']
|
|
|
|
def getBlockchainInfo(self):
|
|
bci = self.rpc('getblockchaininfo')
|
|
|
|
# Adjust verificationprogress to consider blocks wallet has synced
|
|
wallet_blocks = self.rpc_wallet('getinfo')['blocks']
|
|
synced_ind = bci['verificationprogress']
|
|
wallet_synced_ind = wallet_blocks / bci['headers']
|
|
if wallet_synced_ind < synced_ind:
|
|
bci['verificationprogress'] = wallet_synced_ind
|
|
|
|
return bci
|
|
|
|
def getWalletInfo(self):
|
|
rv = {}
|
|
rv = self.rpc_wallet('getinfo')
|
|
wi = self.rpc_wallet('walletinfo')
|
|
balances = self.rpc_wallet('getbalance')
|
|
|
|
default_account_bal = balances['balances'][0] # 0 always default?
|
|
rv['balance'] = default_account_bal['spendable']
|
|
rv['unconfirmed_balance'] = default_account_bal['unconfirmed']
|
|
rv['immature_balance'] = default_account_bal['immaturecoinbaserewards'] + default_account_bal['immaturestakegeneration']
|
|
rv['encrypted'] = True
|
|
rv['locked'] = True if wi['unlocked'] is False else False
|
|
|
|
return rv
|
|
|
|
def getSpendableBalance(self) -> int:
|
|
balances = self.rpc_wallet('getbalance')
|
|
default_account_bal = balances['balances'][0] # 0 always default?
|
|
return self.make_int(default_account_bal['spendable'])
|
|
|
|
def getSeedHash(self, seed: bytes, coin_type_id=None) -> bytes:
|
|
# m / purpose' / coin_type' / account' / change / address_index
|
|
# m/44'/coin_type'/0'/0/0
|
|
|
|
ek = ExtKeyPair(self.coin_type())
|
|
ek.set_seed(seed)
|
|
|
|
coin_type = self.chainparams_network()['bip44'] if coin_type_id is None else coin_type_id
|
|
ek_purpose = ek.derive(44 | (1 << 31))
|
|
ek_coin = ek_purpose.derive(coin_type | (1 << 31))
|
|
ek_account = ek_coin.derive(0 | (1 << 31))
|
|
|
|
return hash160(ek_account.encode_p())
|
|
|
|
def decodeKey(self, encoded_key: str) -> (int, bytes):
|
|
key = b58decode(encoded_key)
|
|
checksum = key[-4:]
|
|
key = key[:-4]
|
|
|
|
if blake256(key)[:4] != checksum:
|
|
raise ValueError('Checksum mismatch')
|
|
return key[2], key[3:]
|
|
|
|
def encodeKey(self, key_bytes: bytes) -> str:
|
|
wif_prefix = self.chainparams_network()['key_prefix']
|
|
key_type = 0 # STEcdsaSecp256k1
|
|
b = wif_prefix.to_bytes(2, 'big') + key_type.to_bytes(1, 'big') + key_bytes
|
|
b += blake256(b)[:4]
|
|
return b58encode(b)
|
|
|
|
def loadTx(self, tx_bytes: bytes) -> CTransaction:
|
|
tx = CTransaction()
|
|
tx.deserialize(tx_bytes)
|
|
return tx
|
|
|
|
def signTx(self, key_bytes: bytes, tx_bytes: bytes, input_n: int, prevout_script: bytes, prevout_value: int) -> bytes:
|
|
tx = self.loadTx(tx_bytes)
|
|
sig_hash = DCRSignatureHash(prevout_script, SigHashType.SigHashAll, tx, input_n)
|
|
|
|
eck = PrivateKey(key_bytes)
|
|
return eck.sign(sig_hash, hasher=None) + bytes((SigHashType.SigHashAll,))
|
|
|
|
def setTxSignatureScript(self, tx_bytes: bytes, script: bytes, txi: int = 0) -> bytes:
|
|
tx = self.loadTx(tx_bytes)
|
|
|
|
tx.vin[txi].signature_script = script
|
|
return tx.serialize()
|
|
|
|
def setTxSignature(self, tx_bytes: bytes, stack, txi: int = 0) -> bytes:
|
|
tx = self.loadTx(tx_bytes)
|
|
|
|
script_data = bytearray()
|
|
for data in stack:
|
|
push_script_data(script_data, data)
|
|
|
|
tx.vin[txi].signature_script = script_data
|
|
test_ser = tx.serialize()
|
|
test_tx = self.loadTx(test_ser)
|
|
|
|
return tx.serialize()
|
|
|
|
def stripTxSignature(self, tx_bytes) -> bytes:
|
|
tx = self.loadTx(tx_bytes)
|
|
return tx.serialize(TxSerializeType.NoWitness)
|
|
|
|
def getTxSignature(self, tx_hex: str, prevout_data, key_wif: str) -> str:
|
|
sig_type, key = self.decodeKey(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 = DCRSignatureHash(prevout_script, SigHashType.SigHashAll, tx, input_n)
|
|
pubkey = PublicKey(K)
|
|
return pubkey.verify(sig[: -1], sig_hash, hasher=None) # Pop the hashtype byte
|
|
|
|
def getTxid(self, tx) -> bytes:
|
|
if isinstance(tx, str):
|
|
tx = bytes.fromhex(tx)
|
|
if isinstance(tx, bytes):
|
|
tx = self.loadTx(tx)
|
|
return tx.TxHash()
|
|
|
|
def getScriptDest(self, script: bytes) -> bytes:
|
|
# P2SH
|
|
script_hash = self.pkh(script)
|
|
assert len(script_hash) == 20
|
|
|
|
return bytes((OP_HASH160,)) + bytes((len(script_hash),)) + script_hash + bytes((OP_EQUAL,))
|
|
|
|
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 getPubkeyHashDest(self, pkh: bytes) -> bytes:
|
|
# P2PKH
|
|
assert len(pkh) == 20
|
|
return bytes((OP_DUP,)) + bytes((OP_HASH160,)) + bytes((len(pkh),)) + pkh + bytes((OP_EQUALVERIFY,)) + bytes((OP_CHECKSIG,))
|
|
|
|
def getPkDest(self, K: bytes) -> bytearray:
|
|
return self.getPubkeyHashDest(self.pkh(K))
|
|
|
|
def getSCLockScriptAddress(self, lock_script: bytes) -> str:
|
|
lock_tx_dest = self.getScriptDest(lock_script)
|
|
return self.encodeScriptDest(lock_tx_dest)
|
|
|
|
def get_fee_rate(self, conf_target: int = 2) -> (float, str):
|
|
chain_client_settings = self._sc.getChainClientSettings(self.coin_type()) # basicswap.json
|
|
override_feerate = chain_client_settings.get('override_feerate', None)
|
|
if override_feerate:
|
|
self._log.debug('Fee rate override used for %s: %f', self.coin_name(), override_feerate)
|
|
return override_feerate, 'override_feerate'
|
|
|
|
min_relay_fee = chain_client_settings.get('min_relay_fee', None)
|
|
|
|
def try_get_fee_rate(self, conf_target):
|
|
# TODO: How to estimate required fee?
|
|
try:
|
|
fee_rate: float = self.rpc_wallet('walletinfo')['txfee']
|
|
assert (fee_rate > 0.0), 'Non positive feerate'
|
|
return fee_rate, 'paytxfee'
|
|
except Exception:
|
|
fee_rate: float = self.rpc('getnetworkinfo')['relayfee']
|
|
return fee_rate, 'relayfee'
|
|
|
|
fee_rate, rate_src = try_get_fee_rate(self, conf_target)
|
|
if min_relay_fee and min_relay_fee > fee_rate:
|
|
self._log.warning('Feerate {} ({}) is below min relay fee {} for {}'.format(self.format_amount(fee_rate, True, 1), rate_src, self.format_amount(min_relay_fee, True, 1), self.coin_name()))
|
|
return min_relay_fee, 'min_relay_fee'
|
|
return fee_rate, rate_src
|
|
|
|
def getNewAddress(self, use_segwit: bool = True, label: str = 'swap_receive') -> str:
|
|
return self.rpc_wallet('getnewaddress')
|
|
|
|
def getWalletTransaction(self, txid: bytes):
|
|
try:
|
|
return bytes.fromhex(self.rpc_wallet('gettransaction', [txid.hex()])['hex'])
|
|
except Exception as ex:
|
|
# TODO: filter errors
|
|
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_wallet('listunspent')
|
|
if unspents is None:
|
|
unspents = []
|
|
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'], u['tree']))
|
|
|
|
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], utxo[3])
|
|
prove_utxos.append(outpoint)
|
|
hasher.update(outpoint[0])
|
|
hasher.update(outpoint[1].to_bytes(2, 'big'))
|
|
hasher.update(outpoint[2].to_bytes(1, 'big'))
|
|
if sum_value >= amount_for:
|
|
break
|
|
utxos_hash = hasher.digest()
|
|
|
|
signature = self.rpc_wallet('signmessage', [sign_for_addr, sign_for_addr + '_swap_proof_' + utxos_hash.hex() + extra_commit_bytes.hex()])
|
|
|
|
return (sign_for_addr, signature, prove_utxos)
|
|
|
|
def withdrawCoin(self, value: float, addr_to: str, subfee: bool = False) -> str:
|
|
if subfee:
|
|
raise ValueError('TODO')
|
|
params = [addr_to, float(value)]
|
|
return self.rpc_wallet('sendtoaddress', params)
|
|
|
|
def isAddressMine(self, address: str, or_watch_only: bool = False) -> bool:
|
|
addr_info = self.rpc_wallet('validateaddress', [address])
|
|
return addr_info.get('ismine', False)
|
|
|
|
def encodeProofUtxos(self, proof_utxos):
|
|
packed_utxos = bytes()
|
|
for utxo in proof_utxos:
|
|
packed_utxos += utxo[0] + utxo[1].to_bytes(2, 'big') + utxo[2].to_bytes(1, 'big')
|
|
return packed_utxos
|
|
|
|
def decodeProofUtxos(self, msg_utxos):
|
|
proof_utxos = []
|
|
if len(msg_utxos) > 0:
|
|
num_utxos = len(msg_utxos) // 34
|
|
p: int = 0
|
|
for i in range(num_utxos):
|
|
proof_utxos.append((msg_utxos[p: p + 32], int.from_bytes(msg_utxos[p + 32: p + 34], 'big'), msg_utxos[p + 34]))
|
|
p += 35
|
|
return proof_utxos
|
|
|
|
def verifyProofOfFunds(self, address: str, signature: bytes, utxos, extra_commit_bytes: bytes):
|
|
hasher = hashlib.sha256()
|
|
sum_value: int = 0
|
|
for outpoint in utxos:
|
|
hasher.update(outpoint[0])
|
|
hasher.update(outpoint[1].to_bytes(2, 'big'))
|
|
hasher.update(outpoint[2].to_bytes(1, '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')
|
|
|
|
sum_value: int = 0
|
|
for outpoint in utxos:
|
|
txout = self.rpc('gettxout', [outpoint[0].hex(), outpoint[1], outpoint[2]])
|
|
sum_value += self.make_int(txout['value'])
|
|
|
|
return sum_value
|
|
|
|
def signCompact(self, k, message):
|
|
message_hash = blake256(bytes(message, 'utf-8'))
|
|
|
|
privkey = PrivateKey(k)
|
|
return privkey.sign_recoverable(message_hash, hasher=None)[:64]
|
|
|
|
def signRecoverable(self, k, message: str) -> bytes:
|
|
message_hash = blake256(bytes(message, 'utf-8'))
|
|
|
|
privkey = PrivateKey(k)
|
|
return privkey.sign_recoverable(message_hash, hasher=None)
|
|
|
|
def verifyCompactSig(self, K, message: str, sig) -> None:
|
|
message_hash = blake256(bytes(message, 'utf-8'))
|
|
pubkey = PublicKey(K)
|
|
rv = pubkey.verify_compact(sig, message_hash, hasher=None)
|
|
assert (rv is True)
|
|
|
|
def verifySigAndRecover(self, sig, message: str) -> bytes:
|
|
message_hash = blake256(bytes(message, 'utf-8'))
|
|
pubkey = PublicKey.from_signature_and_message(sig, message_hash, hasher=None)
|
|
return pubkey.format()
|
|
|
|
def verifyMessage(self, address: str, message: str, signature: str, message_magic: str = None) -> bool:
|
|
if message_magic is None:
|
|
message_magic = self.chainparams()['message_magic']
|
|
|
|
message_bytes = SerialiseNumCompact(len(message_magic)) + bytes(message_magic, 'utf-8') + SerialiseNumCompact(len(message)) + bytes(message, 'utf-8')
|
|
message_hash = blake256(message_bytes)
|
|
signature_bytes = base64.b64decode(signature)
|
|
rec_id = (signature_bytes[0] - 27) & 3
|
|
signature_bytes = signature_bytes[1:] + bytes((rec_id,))
|
|
try:
|
|
pubkey = PublicKey.from_signature_and_message(signature_bytes, message_hash, hasher=None)
|
|
except Exception as e:
|
|
self._log.info('verifyMessage failed: ' + str(e))
|
|
return False
|
|
|
|
address_hash = self.decode_address(address)[2:]
|
|
pubkey_hash = ripemd160(blake256(pubkey.format()))
|
|
|
|
return True if address_hash == pubkey_hash else False
|
|
|
|
def signTxWithWallet(self, tx) -> bytes:
|
|
return bytes.fromhex(self.rpc_wallet('signrawtransaction', [tx.hex()])['hex'])
|
|
|
|
def signTxWithKey(self, tx: bytes, key: bytes) -> bytes:
|
|
key_wif = self.encodeKey(key)
|
|
rv = self.rpc_wallet('signrawtransaction', [tx.hex(), [], [key_wif, ]])
|
|
return bytes.fromhex(rv['hex'])
|
|
|
|
def createRawFundedTransaction(self, addr_to: str, amount: int, sub_fee: bool = False, lock_unspents: bool = True) -> str:
|
|
|
|
# amount can't be a string, else: Failed to parse request: parameter #2 'amounts' must be type float64 (got string)
|
|
float_amount = float(self.format_amount(amount))
|
|
txn = self.rpc('createrawtransaction', [[], {addr_to: float_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_wallet('fundrawtransaction', [txn, 'default', options])['hex']
|
|
|
|
def createRawSignedTransaction(self, addr_to, amount) -> str:
|
|
txn_funded = self.createRawFundedTransaction(addr_to, amount)
|
|
return self.rpc_wallet('signrawtransaction', [txn_funded])['hex']
|
|
|
|
def getLockTxHeight(self, txid, dest_address, bid_amount, rescan_from, find_index: bool = False, vout: int = -1):
|
|
if txid is None:
|
|
self._log.debug('TODO: getLockTxHeight')
|
|
return None
|
|
|
|
found_vout = None
|
|
# Search for txo at vout 0 and 1 if vout is not known
|
|
if vout is None:
|
|
test_range = range(2)
|
|
else:
|
|
test_range = (vout, )
|
|
for try_vout in test_range:
|
|
try:
|
|
txout = self.rpc('gettxout', [txid.hex(), try_vout, 0, True])
|
|
addresses = txout['scriptPubKey']['addresses']
|
|
if len(addresses) != 1 or addresses[0] != dest_address:
|
|
continue
|
|
if self.make_int(txout['value']) != bid_amount:
|
|
self._log.warning('getLockTxHeight found txout {} with incorrect amount {}'.format(txid.hex(), txout['value']))
|
|
continue
|
|
found_vout = try_vout
|
|
break
|
|
except Exception as e:
|
|
# self._log.warning('gettxout {}'.format(e))
|
|
return None
|
|
|
|
if found_vout is None:
|
|
return None
|
|
|
|
block_height: int = 0
|
|
confirmations: int = 0 if 'confirmations' not in txout else txout['confirmations']
|
|
|
|
# TODO: Better way?
|
|
if confirmations > 0:
|
|
block_height = self.getChainHeight() - confirmations
|
|
|
|
rv = {
|
|
'txid': txid.hex(),
|
|
'depth': confirmations,
|
|
'index': found_vout,
|
|
'height': block_height}
|
|
|
|
return rv
|
|
|
|
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())
|
|
|
|
txo = txjs['vout'][n]
|
|
return {
|
|
'txid': txjs['txid'],
|
|
'vout': n,
|
|
'scriptPubKey': txo['scriptPubKey']['hex'],
|
|
'redeemScript': txn_script.hex(),
|
|
'amount': txo['value'],
|
|
}
|
|
|
|
def getHTLCSpendTxVSize(self, redeem: bool = True) -> int:
|
|
tx_vsize = 5 # Add a few bytes, sequence in script takes variable amount of bytes
|
|
tx_vsize += 348 if redeem else 316
|
|
return tx_vsize
|
|
|
|
def createRedeemTxn(self, prevout, output_addr: str, output_value: int, txn_script: bytes = None) -> str:
|
|
tx = CTransaction()
|
|
tx.version = self.txVersion()
|
|
prev_txid = b2i(bytes.fromhex(prevout['txid']))
|
|
tx.vin.append(CTxIn(COutPoint(prev_txid, prevout['vout'], 0)))
|
|
pkh = self.decode_address(output_addr)[2:]
|
|
script = self.getPubkeyHashDest(pkh)
|
|
tx.vout.append(self.txoType()(output_value, script))
|
|
return tx.serialize().hex()
|
|
|
|
def createRefundTxn(self, prevout, output_addr: str, output_value: int, locktime: int, sequence: int, txn_script: bytes = None) -> str:
|
|
tx = CTransaction()
|
|
tx.version = self.txVersion()
|
|
tx.locktime = locktime
|
|
prev_txid = b2i(bytes.fromhex(prevout['txid']))
|
|
tx.vin.append(CTxIn(COutPoint(prev_txid, prevout['vout'], 0), sequence=sequence,))
|
|
pkh = self.decode_address(output_addr)[2:]
|
|
script = self.getPubkeyHashDest(pkh)
|
|
tx.vout.append(self.txoType()(output_value, script))
|
|
return tx.serialize().hex()
|
|
|
|
def verifyRawTransaction(self, tx_hex: str, prevouts):
|
|
inputs_valid: bool = True
|
|
validscripts: int = 0
|
|
|
|
tx_bytes = bytes.fromhex(tx_hex)
|
|
tx = self.loadTx(bytes.fromhex(tx_hex))
|
|
|
|
for i, txi in enumerate(tx.vin):
|
|
prevout_data = prevouts[i]
|
|
redeem_script = bytes.fromhex(prevout_data['redeemScript'])
|
|
prevout_value = self.make_int(prevout_data['amount'])
|
|
sig, pk = extract_sig_and_pk(txi.signature_script)
|
|
|
|
if not sig or not pk:
|
|
self._log.warning(f'verifyRawTransaction failed to extract signature for input {i}')
|
|
continue
|
|
|
|
if self.verifyTxSig(tx_bytes, sig, pk, i, redeem_script, prevout_value):
|
|
validscripts += 1
|
|
|
|
# TODO: validate inputs
|
|
inputs_valid = True
|
|
|
|
return {
|
|
'inputs_valid': inputs_valid,
|
|
'validscripts': validscripts,
|
|
}
|
|
|
|
def getBlockHeaderFromHeight(self, height):
|
|
block_hash = self.rpc('getblockhash', [height])
|
|
return self.rpc('getblockheader', [block_hash])
|
|
|
|
def getBlockHeaderAt(self, time: int, block_after=False):
|
|
blockchaininfo = self.rpc('getblockchaininfo')
|
|
last_block_header = self.rpc('getblockheader', [blockchaininfo['bestblockhash']])
|
|
|
|
max_tries = 15000
|
|
for i in range(max_tries):
|
|
prev_block_header = self.rpc('getblockheader', [last_block_header['previousblockhash']])
|
|
if prev_block_header['time'] <= time:
|
|
return last_block_header if block_after else prev_block_header
|
|
|
|
last_block_header = prev_block_header
|
|
raise ValueError(f'Block header not found at time: {time}')
|
|
|
|
def getMempoolTx(self, txid):
|
|
raise ValueError('TODO')
|
|
|
|
def getBlockWithTxns(self, block_hash: str):
|
|
block = self.rpc('getblock', [block_hash, True, True])
|
|
|
|
return {
|
|
'hash': block['hash'],
|
|
'previousblockhash': block['previousblockhash'],
|
|
'tx': block['rawtx'],
|
|
'confirmations': block['confirmations'],
|
|
'height': block['height'],
|
|
'time': block['time'],
|
|
'version': block['version'],
|
|
'merkleroot': block['merkleroot'],
|
|
}
|
|
|
|
def publishTx(self, tx: bytes):
|
|
return self.rpc('sendrawtransaction', [tx.hex()])
|
|
|
|
def describeTx(self, tx_hex: str):
|
|
return self.rpc('decoderawtransaction', [tx_hex])
|
|
|
|
def fundTx(self, tx: bytes, feerate) -> bytes:
|
|
feerate_str = float(self.format_amount(feerate))
|
|
# TODO: unlock unspents if bid cancelled
|
|
options = {
|
|
'feeRate': feerate_str,
|
|
}
|
|
rv = self.rpc_wallet('fundrawtransaction', [tx.hex(), 'default', options])
|
|
tx_bytes = bytes.fromhex(rv['hex'])
|
|
|
|
tx_obj = self.loadTx(tx_bytes)
|
|
for txi in tx_obj.vin:
|
|
utxos = [{'amount': float(self.format_amount(txi.value_in)),
|
|
'txid': i2h(txi.prevout.hash),
|
|
'vout': txi.prevout.n,
|
|
'tree': txi.prevout.tree}]
|
|
rv = self.rpc_wallet('lockunspent', [False, utxos])
|
|
|
|
return tx_bytes
|
|
|
|
def createSCLockTx(self, value: int, script: bytearray, vkbv: bytes = None) -> bytes:
|
|
tx = CTransaction()
|
|
tx.version = 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 genScriptLockRefundTxScript(self, Kal, Kaf, csv_val) -> bytes:
|
|
|
|
Kal_enc = Kal if len(Kal) == 33 else self.encodePubkey(Kal)
|
|
Kaf_enc = Kaf if len(Kaf) == 33 else self.encodePubkey(Kaf)
|
|
|
|
script = bytearray()
|
|
script += bytes((OP_IF,))
|
|
push_script_data(script, bytes((2,)))
|
|
push_script_data(script, Kal_enc)
|
|
push_script_data(script, Kaf_enc)
|
|
push_script_data(script, bytes((2,)))
|
|
script += bytes((OP_CHECKMULTISIG,))
|
|
script += bytes((OP_ELSE,))
|
|
script += CScriptNum.encode(CScriptNum(csv_val))
|
|
script += bytes((OP_CHECKSEQUENCEVERIFY,))
|
|
script += bytes((OP_DROP,))
|
|
push_script_data(script, Kaf_enc)
|
|
script += bytes((OP_CHECKSIG,))
|
|
script += bytes((OP_ENDIF,))
|
|
|
|
return script
|
|
|
|
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].value
|
|
|
|
tx_lock_id_int = b2i(tx_lock.TxHash())
|
|
|
|
tx = CTransaction()
|
|
tx.version = self.txVersion()
|
|
tx.vin.append(CTxIn(COutPoint(tx_lock_id_int, locked_n, 0)))
|
|
tx.vout.append(self.txoType()(locked_coin, self.getPubkeyHashDest(pkh_dest)))
|
|
|
|
dummy_witness_stack = self.getScriptLockTxDummyWitness(script_lock)
|
|
size = len(self.setTxSignature(tx.serialize(), dummy_witness_stack))
|
|
pay_fee = round(tx_fee_rate * size / 1000)
|
|
tx.vout[0].value = locked_coin - pay_fee
|
|
|
|
fee_info['fee_paid'] = pay_fee
|
|
fee_info['rate_used'] = tx_fee_rate
|
|
fee_info['size'] = size
|
|
|
|
self._log.info('createSCLockSpendTx %s:\n fee_rate, size, fee: %ld, %ld, %ld.',
|
|
tx.TxHash().hex(), tx_fee_rate, size, pay_fee)
|
|
|
|
return tx.serialize(TxSerializeType.NoWitness)
|
|
|
|
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].value
|
|
|
|
tx_lock_id_int = b2i(tx_lock.TxHash())
|
|
|
|
refund_script = self.genScriptLockRefundTxScript(Kal, Kaf, csv_val)
|
|
tx = CTransaction()
|
|
tx.version = self.txVersion()
|
|
tx.vin.append(CTxIn(COutPoint(tx_lock_id_int, locked_n, 0),
|
|
sequence=lock1_value))
|
|
tx.vout.append(self.txoType()(locked_coin, self.getScriptDest(refund_script)))
|
|
|
|
dummy_witness_stack = self.getScriptLockTxDummyWitness(script_lock)
|
|
size = len(self.setTxSignature(tx.serialize(), dummy_witness_stack))
|
|
pay_fee = round(tx_fee_rate * size / 1000)
|
|
tx.vout[0].value = locked_coin - pay_fee
|
|
|
|
self._log.info('createSCLockRefundTx %s:\n fee_rate, size, fee: %ld, %ld, %ld.',
|
|
tx.TxHash().hex(), tx_fee_rate, size, pay_fee)
|
|
|
|
return tx.serialize(TxSerializeType.NoWitness), refund_script, tx.vout[0].value
|
|
|
|
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].value
|
|
|
|
tx_lock_refund_hash_int = b2i(tx_lock_refund.TxHash())
|
|
|
|
tx = CTransaction()
|
|
tx.version = self.txVersion()
|
|
tx.vin.append(CTxIn(COutPoint(tx_lock_refund_hash_int, locked_n, 0),
|
|
sequence=0))
|
|
|
|
tx.vout.append(self.txoType()(locked_coin, self.getPubkeyHashDest(pkh_refund_to)))
|
|
|
|
dummy_witness_stack = self.getScriptLockRefundSpendTxDummyWitness(script_lock_refund)
|
|
size = len(self.setTxSignature(tx.serialize(), dummy_witness_stack))
|
|
pay_fee = round(tx_fee_rate * size / 1000)
|
|
tx.vout[0].value = locked_coin - pay_fee
|
|
|
|
self._log.info('createSCLockRefundSpendTx %s:\n fee_rate, size, fee: %ld, %ld, %ld.',
|
|
tx.TxHash().hex(), tx_fee_rate, size, pay_fee)
|
|
|
|
return tx.serialize(TxSerializeType.NoWitness)
|
|
|
|
def verifySCLockTx(self, tx_bytes, script_out,
|
|
swap_value,
|
|
Kal, Kaf,
|
|
feerate,
|
|
check_lock_tx_inputs, vkbv=None):
|
|
# Verify:
|
|
#
|
|
|
|
# Not necessary to check the lock txn is mineable, as protocol will wait for it to confirm
|
|
# However by checking early we can avoid wasting time processing unmineable txns
|
|
# Check fee is reasonable
|
|
|
|
tx = self.loadTx(tx_bytes)
|
|
txid = self.getTxid(tx)
|
|
self._log.info('Verifying lock tx: {}.'.format(b2h(txid)))
|
|
|
|
ensure(tx.version == self.txVersion(), 'Bad version')
|
|
ensure(tx.locktime == 0, 'Bad locktime')
|
|
ensure(tx.expiry == 0, 'Bad expiry')
|
|
|
|
script_pk = self.getScriptDest(script_out)
|
|
locked_n = findOutput(tx, script_pk)
|
|
ensure(locked_n is not None, 'Lock output not found in tx')
|
|
locked_coin = tx.vout[locked_n].value
|
|
|
|
# Check value
|
|
ensure(locked_coin == swap_value, 'Bad locked value')
|
|
|
|
# Check script
|
|
A, B = extractScriptLockScriptValues(script_out)
|
|
ensure(A == Kal, 'Bad script pubkey')
|
|
ensure(B == Kaf, 'Bad script pubkey')
|
|
|
|
if check_lock_tx_inputs:
|
|
# TODO: Check that inputs are unspent
|
|
# Verify fee rate
|
|
inputs_value = 0
|
|
add_bytes = 0
|
|
add_witness_bytes = 0
|
|
for pi in tx.vin:
|
|
ptx = self.rpc('getrawtransaction', [i2h(pi.prevout.hash), True])
|
|
prevout = ptx['vout'][pi.prevout.n]
|
|
inputs_value += self.make_int(prevout['value'])
|
|
self._log.info('prevout: {}.'.format(prevout))
|
|
prevout_type = prevout['scriptPubKey']['type']
|
|
|
|
'''
|
|
if prevout_type == 'witness_v0_keyhash':
|
|
#add_witness_bytes += 107 # sig 72, pk 33 and 2 size bytes
|
|
#add_witness_bytes += getCompactSizeLen(107)
|
|
else:
|
|
# Assume P2PKH, TODO more types
|
|
add_bytes += 107 # OP_PUSH72 <ecdsa_signature> OP_PUSH33 <public_key>
|
|
'''
|
|
|
|
outputs_value = 0
|
|
for txo in tx.vout:
|
|
outputs_value += txo.nValue
|
|
fee_paid = inputs_value - outputs_value
|
|
assert (fee_paid > 0)
|
|
|
|
size = len(tx.serialize()) + add_witness_bytes
|
|
fee_rate_paid = fee_paid * 1000 // size
|
|
|
|
self._log.info('tx amount, size, feerate: %ld, %ld, %ld', locked_coin, size, fee_rate_paid)
|
|
|
|
if not self.compareFeeRates(fee_rate_paid, feerate):
|
|
self._log.warning('feerate paid doesn\'t match expected: %ld, %ld', fee_rate_paid, feerate)
|
|
# TODO: Display warning to user
|
|
|
|
return txid, locked_n
|
|
|
|
def verifySCLockSpendTx(self, tx_bytes,
|
|
lock_tx_bytes, lock_tx_script,
|
|
a_pkhash_f, feerate, vkbv=None):
|
|
# Verify:
|
|
# Must have only one input with correct prevout (n is always 0) and sequence
|
|
# Must have only one output with destination and amount
|
|
|
|
tx = self.loadTx(tx_bytes)
|
|
txid = self.getTxid(tx)
|
|
self._log.info('Verifying lock spend tx: {}.'.format(b2h(txid)))
|
|
|
|
ensure(tx.version == self.txVersion(), 'Bad version')
|
|
ensure(tx.locktime == 0, 'Bad locktime')
|
|
ensure(tx.expiry == 0, 'Bad expiry')
|
|
ensure(len(tx.vin) == 1, 'tx doesn\'t have one input')
|
|
|
|
lock_tx = self.loadTx(lock_tx_bytes)
|
|
lock_tx_id = self.getTxid(lock_tx)
|
|
|
|
output_script = self.getScriptDest(lock_tx_script)
|
|
locked_n = findOutput(lock_tx, output_script)
|
|
ensure(locked_n is not None, 'Output not found in tx')
|
|
locked_coin = lock_tx.vout[locked_n].value
|
|
|
|
ensure(tx.vin[0].sequence == 0, 'Bad input nSequence')
|
|
ensure(len(tx.vin[0].signature_script) == 0, 'Input sig not empty')
|
|
ensure(i2b(tx.vin[0].prevout.hash) == lock_tx_id and tx.vin[0].prevout.n == locked_n, 'Input prevout mismatch')
|
|
|
|
ensure(len(tx.vout) == 1, 'tx doesn\'t have one output')
|
|
p2wpkh = self.getPubkeyHashDest(a_pkhash_f)
|
|
ensure(tx.vout[0].script_pubkey == p2wpkh, 'Bad output destination')
|
|
|
|
# The value of the lock tx output should already be verified, if the fee is as expected the difference will be the correct amount
|
|
fee_paid = locked_coin - tx.vout[0].value
|
|
assert (fee_paid > 0)
|
|
|
|
dummy_witness_stack = self.getScriptLockTxDummyWitness(lock_tx_script)
|
|
size = len(self.setTxSignature(tx.serialize(), dummy_witness_stack))
|
|
fee_rate_paid = fee_paid * 1000 // size
|
|
|
|
self._log.info('tx amount, size, feerate: %ld, %ld, %ld', tx.vout[0].value, size, fee_rate_paid)
|
|
|
|
if not self.compareFeeRates(fee_rate_paid, feerate):
|
|
raise ValueError('Bad fee rate, expected: {}'.format(feerate))
|
|
|
|
return True
|
|
|
|
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=None):
|
|
# Verify:
|
|
# Must have only one input with correct prevout and sequence
|
|
# Must have only one output to the p2wsh of the lock refund script
|
|
# Output value must be locked_coin - lock tx fee
|
|
|
|
tx = self.loadTx(tx_bytes)
|
|
txid = self.getTxid(tx)
|
|
self._log.info('Verifying lock refund tx: {}.'.format(b2h(txid)))
|
|
|
|
ensure(tx.version == self.txVersion(), 'Bad version')
|
|
ensure(tx.locktime == 0, 'locktime not 0')
|
|
ensure(tx.expiry == 0, 'Bad expiry')
|
|
ensure(len(tx.vin) == 1, 'tx doesn\'t have one input')
|
|
|
|
ensure(tx.vin[0].sequence == prevout_seq, 'Bad input sequence')
|
|
ensure(i2b(tx.vin[0].prevout.hash) == prevout_id and tx.vin[0].prevout.n == prevout_n and tx.vin[0].prevout.tree == 0, 'Input prevout mismatch')
|
|
ensure(len(tx.vin[0].signature_script) == 0, 'Input sig not empty')
|
|
|
|
ensure(len(tx.vout) == 1, 'tx doesn\'t have one output')
|
|
|
|
script_pk = self.getScriptDest(script_out)
|
|
locked_n = findOutput(tx, script_pk)
|
|
ensure(locked_n is not None, 'Output not found in tx')
|
|
locked_coin = tx.vout[locked_n].value
|
|
|
|
# Check script and values
|
|
A, B, csv_val, C = extractScriptLockRefundScriptValues(script_out)
|
|
ensure(A == Kal, 'Bad script pubkey')
|
|
ensure(B == Kaf, 'Bad script pubkey')
|
|
ensure(csv_val == csv_val_expect, 'Bad script csv value')
|
|
ensure(C == Kaf, 'Bad script pubkey')
|
|
|
|
fee_paid = swap_value - locked_coin
|
|
assert (fee_paid > 0)
|
|
|
|
dummy_witness_stack = self.getScriptLockTxDummyWitness(prevout_script)
|
|
size = len(self.setTxSignature(tx.serialize(), dummy_witness_stack))
|
|
fee_rate_paid = fee_paid * 1000 // size
|
|
|
|
self._log.info('tx amount, size, feerate: %ld, %ld, %ld', locked_coin, size, fee_rate_paid)
|
|
|
|
if not self.compareFeeRates(fee_rate_paid, feerate):
|
|
raise ValueError('Bad fee rate, expected: {}'.format(feerate))
|
|
|
|
return txid, locked_coin, locked_n
|
|
|
|
def verifySCLockRefundSpendTx(self, tx_bytes, lock_refund_tx_bytes,
|
|
lock_refund_tx_id, prevout_script,
|
|
Kal,
|
|
prevout_n, prevout_value, feerate, vkbv=None):
|
|
# Verify:
|
|
# Must have only one input with correct prevout (n is always 0) and sequence
|
|
# Must have only one output sending lock refund tx value - fee to leader's address, TODO: follower shouldn't need to verify destination addr
|
|
tx = self.loadTx(tx_bytes)
|
|
txid = self.getTxid(tx)
|
|
self._log.info('Verifying lock refund spend tx: {}.'.format(b2h(txid)))
|
|
|
|
ensure(tx.version == self.txVersion(), 'Bad version')
|
|
ensure(tx.locktime == 0, 'locktime not 0')
|
|
ensure(tx.expiry == 0, 'Bad expiry')
|
|
ensure(len(tx.vin) == 1, 'tx doesn\'t have one input')
|
|
|
|
ensure(tx.vin[0].sequence == 0, 'Bad input sequence')
|
|
ensure(len(tx.vin[0].signature_script) == 0, 'Input sig not empty')
|
|
ensure(i2b(tx.vin[0].prevout.hash) == lock_refund_tx_id and tx.vin[0].prevout.n == 0 and tx.vin[0].prevout.tree == 0, 'Input prevout mismatch')
|
|
|
|
ensure(len(tx.vout) == 1, 'tx doesn\'t have one output')
|
|
|
|
# Destination doesn't matter to the follower
|
|
'''
|
|
p2wpkh = CScript([OP_0, hash160(Kal)])
|
|
locked_n = findOutput(tx, p2wpkh)
|
|
ensure(locked_n is not None, 'Output not found in lock refund spend tx')
|
|
'''
|
|
tx_value = tx.vout[0].value
|
|
|
|
fee_paid = prevout_value - tx_value
|
|
assert (fee_paid > 0)
|
|
|
|
dummy_witness_stack = self.getScriptLockRefundSpendTxDummyWitness(prevout_script)
|
|
size = len(self.setTxSignature(tx.serialize(), dummy_witness_stack))
|
|
fee_rate_paid = fee_paid * 1000 // size
|
|
|
|
self._log.info('tx amount, size, feerate: %ld, %ld, %ld', tx_value, size, fee_rate_paid)
|
|
|
|
if not self.compareFeeRates(fee_rate_paid, feerate):
|
|
raise ValueError('Bad fee rate, expected: {}'.format(feerate))
|
|
|
|
return True
|
|
|
|
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_amount = tx_lock_refund.vout[locked_n].value
|
|
|
|
A, B, lock2_value, C = extractScriptLockRefundScriptValues(script_lock_refund)
|
|
|
|
tx_lock_refund_hash_int = b2i(tx_lock_refund.TxHash())
|
|
|
|
tx = CTransaction()
|
|
tx.version = self.txVersion()
|
|
tx.vin.append(CTxIn(COutPoint(tx_lock_refund_hash_int, locked_n, 0),
|
|
sequence=lock2_value,))
|
|
|
|
tx.vout.append(self.txoType()(locked_amount, self.getPubkeyHashDest(pkh_dest)))
|
|
|
|
dummy_witness_stack = self.getScriptLockRefundSwipeTxDummyWitness(script_lock_refund)
|
|
size = len(self.setTxSignature(tx.serialize(), dummy_witness_stack))
|
|
pay_fee = round(tx_fee_rate * size / 1000)
|
|
tx.vout[0].value = locked_amount - pay_fee
|
|
|
|
self._log.info('createSCLockRefundSpendToFTx %s:\n fee_rate, size, fee: %ld, %ld, %ld.',
|
|
tx.TxHash().hex(), tx_fee_rate, size, pay_fee)
|
|
|
|
return tx.serialize(TxSerializeType.NoWitness)
|
|
|
|
def signTxOtVES(self, key_sign: bytes, pubkey_encrypt: bytes, tx_bytes: bytes, input_n: int, prevout_script: bytes, prevout_value: int) -> bytes:
|
|
tx = self.loadTx(tx_bytes)
|
|
sig_hash = DCRSignatureHash(prevout_script, SigHashType.SigHashAll, tx, input_n)
|
|
|
|
return ecdsaotves_enc_sign(key_sign, pubkey_encrypt, sig_hash)
|
|
|
|
def verifyTxOtVES(self, tx_bytes: bytes, ct: bytes, Ks: bytes, Ke: bytes, input_n: int, prevout_script: bytes, prevout_value):
|
|
tx = self.loadTx(tx_bytes)
|
|
sig_hash = DCRSignatureHash(prevout_script, SigHashType.SigHashAll, tx, input_n)
|
|
return ecdsaotves_enc_verify(Ks, Ke, sig_hash, ct)
|
|
|
|
def decryptOtVES(self, k: bytes, esig: bytes) -> bytes:
|
|
return ecdsaotves_dec_sig(k, esig) + bytes((SigHashType.SigHashAll,))
|
|
|
|
def recoverEncKey(self, esig, sig, K):
|
|
return ecdsaotves_rec_enc_key(K, esig, sig[:-1]) # Strip sighash type
|
|
|
|
def getTxOutputPos(self, tx, script):
|
|
if isinstance(tx, bytes):
|
|
tx = self.loadTx(tx)
|
|
script_pk = self.getScriptDest(script)
|
|
return findOutput(tx, script_pk)
|
|
|
|
def getScriptLockTxDummyWitness(self, script: bytes):
|
|
return [
|
|
bytes(72),
|
|
bytes(72),
|
|
bytes(len(script))
|
|
]
|
|
|
|
def getScriptLockRefundSpendTxDummyWitness(self, script: bytes):
|
|
return [
|
|
bytes(72),
|
|
bytes(72),
|
|
bytes((1,)),
|
|
bytes(len(script))
|
|
]
|
|
|
|
def extractLeaderSig(self, tx_bytes: bytes) -> bytes:
|
|
tx = self.loadTx(tx_bytes)
|
|
|
|
sig_len = tx.vin[0].signature_script[0]
|
|
return tx.vin[0].signature_script[1: 1 + sig_len]
|
|
|
|
def extractFollowerSig(self, tx_bytes: bytes) -> bytes:
|
|
tx = self.loadTx(tx_bytes)
|
|
|
|
sig_len = tx.vin[0].signature_script[0]
|
|
ofs = 1 + sig_len
|
|
sig_len = tx.vin[0].signature_script[ofs]
|
|
ofs += 1
|
|
return tx.vin[0].signature_script[ofs: ofs + sig_len]
|
|
|
|
def listInputs(self, tx_bytes: bytes):
|
|
tx = self.loadTx(tx_bytes)
|
|
|
|
all_locked = self.rpc_wallet('listlockunspent')
|
|
inputs = []
|
|
for txi in tx.vin:
|
|
txid_hex = i2h(txi.prevout.hash)
|
|
islocked = any([txid_hex == a['txid'] and txi.prevout.n == a['vout'] for a in all_locked])
|
|
inputs.append({'txid': txid_hex, 'vout': txi.prevout.n, 'islocked': islocked})
|
|
return inputs
|
|
|
|
def unlockInputs(self, tx_bytes):
|
|
tx = self.loadTx(tx_bytes)
|
|
|
|
inputs = []
|
|
for txi in tx.vin:
|
|
inputs.append({'amount': float(self.format_amount(txi.value_in)), 'txid': i2h(txi.prevout.hash), 'vout': txi.prevout.n, 'tree': txi.prevout.tree})
|
|
self.rpc_wallet('lockunspent', [True, inputs])
|
|
|
|
def getWalletRestoreHeight(self) -> int:
|
|
start_time = self.rpc_wallet('getinfo')['keypoololdest']
|
|
|
|
blockchaininfo = self.getBlockchainInfo()
|
|
best_block = blockchaininfo['bestblockhash']
|
|
|
|
chain_synced = round(blockchaininfo['verificationprogress'], 3)
|
|
if chain_synced < 1.0:
|
|
raise ValueError('{} chain isn\'t synced.'.format(self.coin_name()))
|
|
|
|
if start_time == 0:
|
|
self._log.debug('Using genesis block for restore height as keypoololdest is 0.')
|
|
return 0
|
|
|
|
self._log.info('Finding block at time: {} for restore height.'.format(start_time))
|
|
|
|
blocks_searched: int = 0
|
|
rpc_conn = self.open_rpc()
|
|
try:
|
|
block_hash = best_block
|
|
while True:
|
|
block_header = self.json_request(rpc_conn, 'getblockheader', [block_hash])
|
|
if block_header['time'] < start_time:
|
|
return block_header['height']
|
|
# genesis block
|
|
if block_header['previousblockhash'] == '0000000000000000000000000000000000000000000000000000000000000000':
|
|
return block_header['height']
|
|
|
|
block_hash = block_header['previousblockhash']
|
|
blocks_searched += 1
|
|
if blocks_searched % 10000 == 0:
|
|
self._log.debug('Still finding restore height, block at height {} has time {}.'.format(block_header['height'], block_header['time']))
|
|
finally:
|
|
self.close_rpc(rpc_conn)
|
|
raise ValueError('{} wallet restore height not found.'.format(self.coin_name()))
|
|
|
|
def createBLockTx(self, Kbs, output_amount, vkbv=None) -> bytes:
|
|
tx = CTransaction()
|
|
tx.version = self.txVersion()
|
|
script_pk = self.getPkDest(Kbs)
|
|
tx.vout.append(self.txoType()(output_amount, script_pk))
|
|
return tx.serialize()
|
|
|
|
def publishBLockTx(self, kbv, Kbs, output_amount, feerate, unlock_time: int = 0) -> bytes:
|
|
b_lock_tx = self.createBLockTx(Kbs, output_amount)
|
|
|
|
b_lock_tx = self.fundTx(b_lock_tx, feerate)
|
|
b_lock_tx_id = self.getTxid(b_lock_tx)
|
|
b_lock_tx = self.signTxWithWallet(b_lock_tx)
|
|
|
|
return bytes.fromhex(self.publishTx(b_lock_tx))
|
|
|
|
def getBLockSpendTxFee(self, tx, fee_rate: int) -> int:
|
|
witness_bytes = 115
|
|
size = len(tx.serialize()) + witness_bytes
|
|
pay_fee = round(fee_rate * size / 1000)
|
|
self._log.info(f'BLockSpendTx fee_rate, vsize, fee: {fee_rate}, {size}, {pay_fee}.')
|
|
return pay_fee
|
|
|
|
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, lock_tx_vout=None) -> bytes:
|
|
self._log.info('spendBLockTx %s:\n', chain_b_lock_txid.hex())
|
|
locked_n = lock_tx_vout
|
|
|
|
Kbs = self.getPubkey(kbs)
|
|
script_pk = self.getPkDest(Kbs)
|
|
|
|
if locked_n is None:
|
|
self._log.debug(f'Unknown lock vout, searching tx: {chain_b_lock_txid.hex()}')
|
|
# When refunding a lock tx, it should be in the wallet as a sent tx
|
|
wtx = self.rpc_wallet('gettransaction', [chain_b_lock_txid.hex(), ])
|
|
lock_tx = self.loadTx(bytes.fromhex(wtx['hex']))
|
|
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.version = self.txVersion()
|
|
|
|
chain_b_lock_txid_int = b2i(chain_b_lock_txid)
|
|
|
|
tx.vin.append(CTxIn(COutPoint(chain_b_lock_txid_int, locked_n, 0),
|
|
sequence=0))
|
|
tx.vout.append(self.txoType()(cb_swap_value, self.getPubkeyHashDest(pkh_to)))
|
|
|
|
pay_fee = self.getBLockSpendTxFee(tx, b_fee)
|
|
tx.vout[0].value = cb_swap_value - pay_fee
|
|
|
|
b_lock_spend_tx = tx.serialize()
|
|
b_lock_spend_tx = self.signTxWithKey(b_lock_spend_tx, kbs)
|
|
|
|
return bytes.fromhex(self.publishTx(b_lock_spend_tx))
|
|
|
|
def findTxnByHash(self, txid_hex: str):
|
|
try:
|
|
txout = self.rpc('gettxout', [txid_hex, 0, 0, True])
|
|
except Exception as e:
|
|
# self._log.warning('gettxout {}'.format(e))
|
|
return None
|
|
|
|
confirmations: int = 0 if 'confirmations' not in txout else txout['confirmations']
|
|
if confirmations >= self.blocks_confirmed:
|
|
block_height = self.getChainHeight() - confirmations # TODO: Better way?
|
|
return {'txid': txid_hex, 'amount': 0, 'height': block_height}
|
|
return None
|
|
|
|
def encodeSharedAddress(self, Kbv, Kbs):
|
|
return self.pkh_to_address(self.pkh(Kbs))
|
|
|
|
def isTxExistsError(self, err_str: str) -> bool:
|
|
return 'transaction already exists' in err_str or 'already have transaction' in err_str
|
|
|
|
def isTxNonFinalError(self, err_str: str) -> bool:
|
|
return 'locks on inputs not met' in err_str
|