def sync(self):
"""Sync the state of all payment channels."""
with self.lock:
# Look up all channels
channel_query = self._db.pc.lookup()
# Check whether the return result is a single Channel or list
if isinstance(channel_query, Channel):
payment_channels = [channel_query]
else:
payment_channels = channel_query
# Return if there are no payment channels to sync
if not payment_channels:
return
for pc in payment_channels:
# Skip sync if channel is closed
if pc.state == ChannelSQLite3.CLOSED:
continue
# Check for deposit confirmation
if pc.state == ChannelSQLite3.CONFIRMING and self._blockchain.check_confirmed(pc.deposit_txid):
self._db.pc.update_state(pc.deposit_txid, ChannelSQLite3.READY)
# Check if channel got closed
if pc.state in (ChannelSQLite3.CONFIRMING, ChannelSQLite3.READY) and pc.payment_tx:
redeem_script = PaymentChannelRedeemScript.from_bytes(pc.payment_tx.inputs[0].script[-1])
deposit_tx_utxo_index = pc.deposit_tx.output_index_for_address(redeem_script.hash160())
spend_txid = self._blockchain.lookup_spend_txid(pc.deposit_txid, deposit_tx_utxo_index)
if spend_txid:
self._db.pc.update_state(pc.deposit_txid, ChannelSQLite3.CLOSED)
# Check for channel expiration
if pc.state != ChannelSQLite3.CLOSED:
if time.time() + PaymentServer.EXP_TIME_BUFFER > pc.expires_at and pc.payment_tx:
redeem_script = PaymentChannelRedeemScript.from_bytes(pc.payment_tx.inputs[0].script[-1])
self._wallet.sign_half_signed_payment(pc.payment_tx, redeem_script)
self._blockchain.broadcast_tx(pc.payment_tx.to_hex())
self._db.pc.update_payment(pc.deposit_txid, pc.payment_tx, pc.last_payment_amount)
self._db.pc.update_state(pc.deposit_txid, ChannelSQLite3.CLOSED)
def open(self, deposit_tx, redeem_script):
"""Open a payment channel.
Args:
deposit_tx (string): signed deposit transaction which pays to a
2 of 2 multisig script hash.
redeem_script (string): the redeem script that comprises the script
hash so that the merchant can verify.
Returns:
(string): deposit transaction id
"""
with self.lock:
# Parse payment channel `open` parameters
deposit_tx = Transaction.from_hex(deposit_tx)
redeem_script = PaymentChannelRedeemScript.from_bytes(codecs.decode(redeem_script, 'hex_codec'))
# Verify that the deposit pays to the redeem script
output_index = deposit_tx.output_index_for_address(redeem_script.hash160())
if output_index is None:
raise BadTransactionError('Deposit does not pay to the provided script hash.')
# Parse payment channel data for open
deposit_txid = str(deposit_tx.hash)
merch_pubkey = codecs.encode(redeem_script.merchant_public_key.compressed_bytes, 'hex_codec').decode()
amount = deposit_tx.outputs[output_index].value
# Verify that one of the public keys belongs to the merchant
valid_merchant_public_key = self._wallet.validate_merchant_public_key(redeem_script.merchant_public_key)
if not valid_merchant_public_key:
raise BadTransactionError('Public key does not belong to the merchant.')
# Verify that the deposit is not already part of a payment channel
if self._db.pc.lookup(deposit_txid):
raise BadTransactionError('That deposit has already been used to create a channel.')
# Verify that the lock time is an allowable amount in the future
minimum_locktime = int(time.time()) + self.MIN_EXP_TIME
if redeem_script.expiration_time < minimum_locktime:
raise TransactionVerificationError('Transaction locktime must be further in the future.')
# Open and save the payment channel
channel = self._db.pc.create(
deposit_tx, merch_pubkey, amount, redeem_script.expiration_time)
# Set the channel to `ready` if zeroconf is enabled
if self.zeroconf:
self._db.pc.update_state(deposit_txid, ChannelSQLite3.READY)
return str(deposit_tx.hash)
def close(self, deposit_txid, deposit_txid_signature):
"""Close a payment channel.
Args:
deposit_txid (string): string representation of the deposit
transaction hash. This is used to look up the payment channel.
deposit_txid_signature (two1.lib.bitcoin.Signature): a signature
consisting solely of the deposit_txid to verify the
authenticity of the close request.
"""
with self.lock:
channel = self._db.pc.lookup(deposit_txid)
# Verify that the requested channel exists
if not channel:
raise PaymentChannelNotFoundError('Related channel not found.')
# Parse payment channel `close` parameters
try:
signature_der = codecs.decode(deposit_txid_signature, 'hex_codec')
deposit_txid_signature = Signature.from_der(signature_der)
except TypeError:
raise TransactionVerificationError('Invalid signature provided.')
# Verify that there is a valid payment to close
if not channel.payment_tx:
raise BadTransactionError('No payments made in channel.')
# Verify that the user is authorized to close the channel
payment_tx = channel.payment_tx
redeem_script = PaymentChannelRedeemScript.from_bytes(payment_tx.inputs[0].script[-1])
sig_valid = redeem_script.customer_public_key.verify(
deposit_txid.encode(), deposit_txid_signature)
if not sig_valid:
raise TransactionVerificationError('Invalid signature.')
# Sign the final transaction
self._wallet.sign_half_signed_payment(payment_tx, redeem_script)
# Broadcast payment transaction to the blockchain
self._blockchain.broadcast_tx(payment_tx.to_hex())
# Record the broadcast in the database
self._db.pc.update_state(deposit_txid, ChannelSQLite3.CLOSED)
return str(payment_tx.hash)
def receive_payment(self, deposit_txid, payment_tx):
"""Receive and process a payment within the channel.
The customer makes a payment in the channel by sending the merchant a
half-signed payment transaction. The merchant signs the other half of
the transaction and saves it in its records (but does not broadcast it
or send it to the customer). The merchant responds with 200 to verify
that the payment was handled successfully.
Args:
deposit_txid (string): string representation of the deposit
transaction hash. This is used to look up the payment channel.
payment_tx (string): half-signed payment transaction from a
customer.
Returns:
(string): payment transaction id
"""
with self.lock:
# Parse payment channel `payment` parameters
payment_tx = Transaction.from_hex(payment_tx)
# Get channel and addresses related to the deposit
channel = self._db.pc.lookup(deposit_txid)
if not channel:
raise PaymentChannelNotFoundError('Related channel not found.')
# Get merchant public key information from payment channel
redeem_script = PaymentChannelRedeemScript.from_bytes(payment_tx.inputs[0].script[-1])
merch_pubkey = redeem_script.merchant_public_key
# Verify that the payment has a valid signature from the customer
txn_copy = payment_tx._copy_for_sig(0, Transaction.SIG_HASH_ALL, redeem_script)
msg_to_sign = bytes(Hash.dhash(bytes(txn_copy) + pack_u32(Transaction.SIG_HASH_ALL)))
sig = Signature.from_der(payment_tx.inputs[0].script[0][:-1])
if not redeem_script.customer_public_key.verify(msg_to_sign, sig, False):
raise BadTransactionError('Invalid payment signature.')
# Verify the length of the script is what we expect
if len(payment_tx.inputs[0].script) != 3:
raise BadTransactionError('Invalid payment channel transaction structure.')
# Verify the script template is valid for accepting a merchant signature
if (not Script.validate_template(payment_tx.inputs[0].script, [bytes, 'OP_1', bytes]) and
not Script.validate_template(payment_tx.inputs[0].script, [bytes, 'OP_TRUE', bytes])):
raise BadTransactionError('Invalid payment channel transaction structure.')
# Verify that the payment channel is ready
if channel.state == ChannelSQLite3.CONFIRMING:
raise ChannelClosedError('Payment channel not ready.')
elif channel.state == ChannelSQLite3.CLOSED:
raise ChannelClosedError('Payment channel closed.')
# Verify that payment is made to the merchant's pubkey
index = payment_tx.output_index_for_address(merch_pubkey.hash160())
if index is None:
raise BadTransactionError('Payment must pay to merchant pubkey.')
# Verify that both payments are not below the dust limit
if any(p.value < PaymentServer.DUST_LIMIT for p in payment_tx.outputs):
raise BadTransactionError(
'Final payment must have outputs greater than {}.'.format(PaymentServer.DUST_LIMIT))
# Validate that the payment is more than the last one
new_pmt_amt = payment_tx.outputs[index].value
if new_pmt_amt <= channel.last_payment_amount:
raise BadTransactionError('Payment must be greater than 0.')
# Verify that the transaction has adequate fees
net_pmt_amount = sum([d.value for d in payment_tx.outputs])
deposit_amount = channel.amount
if deposit_amount < net_pmt_amount + PaymentServer.MIN_TX_FEE:
raise BadTransactionError('Payment must have adequate fees.')
# Update the current payment transaction
self._db.pc.update_payment(deposit_txid, payment_tx, new_pmt_amt)
self._db.pmt.create(deposit_txid, payment_tx, new_pmt_amt - channel.last_payment_amount)
return str(payment_tx.hash)