Esempio n. 1
0
    def sync(self):
        """Sync the state of all payment channels."""
        # 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)
Esempio n. 2
0
    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
        """
        # 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)
        merchant_public_key = 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_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
        self._db.pc.create(deposit_tx, merchant_public_key, 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)
Esempio n. 3
0
def _create_client_payment(client, num):
    """Mock client transaction for a payment in a channel."""
    customer_public_key = cust_wallet.get_payout_public_key()
    merchant_public_key = merch_wallet.get_payout_public_key()
    deposit_tx = Transaction.from_hex(client.deposit_tx)
    redeem_script = PaymentChannelRedeemScript.from_bytes(codecs.decode(client.redeem_script, 'hex_codec'))
    return cust_wallet.create_payment_tx(
        deposit_tx, redeem_script, merchant_public_key, customer_public_key,
        TEST_PMT_AMOUNT * num, TEST_FEE_AMOUNT).to_hex()
Esempio n. 4
0
    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)
Esempio n. 5
0
def _create_client_txs():
    """Mock client transactions for opening a channel."""
    # Collect public keys
    expiration_time = int(time.time() + TEST_EXPIRY)
    customer_public_key = cust_wallet.get_payout_public_key()
    merchant_public_key = merch_wallet.get_payout_public_key()

    # Build redeem script
    redeem_script = PaymentChannelRedeemScript(
        merchant_public_key, customer_public_key, expiration_time)

    # Build deposit tx
    deposit_tx = cust_wallet.create_deposit_tx(redeem_script.hash160())

    # Build payment tx
    payment_tx = cust_wallet.create_payment_tx(
        deposit_tx, redeem_script, merchant_public_key,
        customer_public_key, TEST_PMT_AMOUNT, TEST_FEE_AMOUNT)

    return ClientVals(deposit_tx.to_hex(), payment_tx.to_hex(), redeem_script.to_hex())
Esempio n. 6
0
def _create_client_payment(client, num):
    """Mock client transaction for a payment in a channel."""
    customer_public_key = cust_wallet.get_payout_public_key()
    merchant_public_key = merch_wallet.get_payout_public_key()
    deposit_tx = Transaction.from_hex(client.deposit_tx)
    redeem_script = PaymentChannelRedeemScript.from_bytes(
        codecs.decode(client.redeem_script, 'hex_codec'))
    return cust_wallet.create_payment_tx(deposit_tx, redeem_script,
                                         merchant_public_key,
                                         customer_public_key,
                                         TEST_PMT_AMOUNT * num,
                                         TEST_FEE_AMOUNT).to_hex()
Esempio n. 7
0
    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)
Esempio n. 8
0
def _create_client_txs():
    """Mock client transactions for opening a channel."""
    # Collect public keys
    expiration_time = int(time.time() + TEST_EXPIRY)
    customer_public_key = cust_wallet.get_payout_public_key()
    merchant_public_key = merch_wallet.get_payout_public_key()

    # Build redeem script
    redeem_script = PaymentChannelRedeemScript(merchant_public_key,
                                               customer_public_key,
                                               expiration_time)

    # Build deposit tx
    deposit_tx = cust_wallet.create_deposit_tx(redeem_script.hash160())

    # Build payment tx
    payment_tx = cust_wallet.create_payment_tx(deposit_tx, redeem_script,
                                               merchant_public_key,
                                               customer_public_key,
                                               TEST_PMT_AMOUNT,
                                               TEST_FEE_AMOUNT)

    return ClientVals(deposit_tx.to_hex(), payment_tx.to_hex(),
                      redeem_script.to_hex())
Esempio n. 9
0
    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.bitcoin.Signature): a signature
                consisting solely of the deposit_txid to verify the
                authenticity of the close request.
        """
        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)
Esempio n. 10
0
    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.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)
Esempio n. 11
0
    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
        """
        # 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:
            confirmed = self._blockchain.check_confirmed(channel.deposit_txid)
            if confirmed:
                self._db.pc.update_state(channel.deposit_txid,
                                         ChannelSQLite3.READY)
            else:
                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
        for output_index, output in enumerate(payment_tx.outputs):
            if output.value < PaymentServer.DUST_LIMIT:
                # Payment to merchant is less than dust limit
                if output_index == index:
                    raise BadTransactionError(
                        'Initial payment must be greater than {}.'.format(
                            PaymentServer.DUST_LIMIT))
                # Payment to customer is less than dust limit
                else:
                    raise BadTransactionError(
                        'Payment channel balance is not large enough to make payment.'
                    )

        # 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)
Esempio n. 12
0
    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
        """
        # 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
        merchant_public_key = PublicKey.from_hex(channel.merchant_pubkey)

        # Verify that redeem script contains the merchant public key
        redeem_script = PaymentChannelRedeemScript.from_bytes(payment_tx.inputs[0].script[-1])
        if redeem_script.merchant_public_key.to_hex() != merchant_public_key.to_hex():
            raise BadTransactionError('Invalid merchant pubkey.')

        # 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:
            confirmed = self._blockchain.check_confirmed(channel.deposit_txid)
            if confirmed:
                self._db.pc.update_state(channel.deposit_txid, ChannelSQLite3.READY)
            else:
                raise ChannelClosedError('Payment channel not ready.')
        elif channel.state == ChannelSQLite3.CLOSED:
            raise ChannelClosedError('Payment channel closed.')

        # Verify that payment is made to the merchant public key
        index = payment_tx.output_index_for_address(merchant_public_key.hash160())
        if index is None:
            raise BadTransactionError('Payment must pay to merchant pubkey.')

        # Verify that both payments are not below the dust limit
        for output_index, output in enumerate(payment_tx.outputs):
            if output.value < PaymentServer.DUST_LIMIT:
                # Payment to merchant is less than dust limit
                if output_index == index:
                    raise BadTransactionError(
                        'Initial payment must be greater than {}.'.format(PaymentServer.DUST_LIMIT))
                # Payment to customer is less than dust limit
                else:
                    raise BadTransactionError(
                        'Payment channel balance is not large enough to make payment.')

        # 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
        fee = deposit_amount - net_pmt_amount
        if fee < PaymentServer.MIN_TX_FEE:
            raise BadTransactionError('Payment must have adequate fees.')

        # Recreate redeem script from merchant side
        redeem_script_copy = PaymentChannelRedeemScript(
            merchant_public_key,
            redeem_script.customer_public_key,
            channel.expires_at)
        if redeem_script.to_hex() != redeem_script_copy.to_hex():
            raise BadTransactionError('Invalid redeem script.')

        # Recreate customer payment from merchant side
        payment_tx_copy = self._wallet.create_unsigned_payment_tx(
            channel.deposit_tx, redeem_script, new_pmt_amt, fee)

        # Recreate signed input script using signature from customer
        hash_type = pack_compact_int(Transaction.SIG_HASH_ALL)
        signed_input_script = Script(
            [sig.to_der() + hash_type, "OP_1", bytes(redeem_script)])
        payment_tx_copy.inputs[0].script = signed_input_script

        if payment_tx.to_hex() != payment_tx_copy.to_hex():
            raise BadTransactionError('Invalid payment channel transaction structure.')

        # Update the current payment transaction
        self._db.pc.update_payment(deposit_txid, payment_tx_copy, new_pmt_amt)
        self._db.pmt.create(deposit_txid, payment_tx_copy, new_pmt_amt - channel.last_payment_amount)

        return str(payment_tx_copy.hash)
Esempio n. 13
0
    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)