def select_coins(wallet,
                     token_id,
                     amount,
                     config,
                     isInvoice=False,
                     *,
                     domain=None):
        token_outputs_amts = []
        if isinstance(amount, list):
            amt = sum(amount) or 0
            token_outputs_amts.extend(amount)
        else:
            amt = amount or 0
            token_outputs_amts.append(amt)

        valid_bal, _, _, unfrozen_bal, _ = wallet.get_slp_token_balance(
            token_id, config)

        if amt > valid_bal:
            raise NotEnoughFundsSlp("Not enough token funds.")
        if valid_bal >= amt > unfrozen_bal:
            raise NotEnoughUnfrozenFundsSlp("Not enough unfrozen token funds.")

        slp_coins = wallet.get_slp_spendable_coins(token_id, domain, config,
                                                   isInvoice)
        slp_coins = sorted(slp_coins, key=lambda k: -k['token_value'])

        selected_slp_coins = []
        total_amt_added = 0
        for coin in slp_coins:
            if total_amt_added < amt:
                selected_slp_coins.append(coin)
                total_amt_added += coin['token_value']
            else:
                break

        slp_op_return_msg = None
        if total_amt_added > 0:
            token_change = total_amt_added - amt
            if token_change > 0:
                token_outputs_amts.append(token_change)
            token_type = wallet.token_types[token_id]['class']
            slp_op_return_msg = slp.buildSendOpReturnOutput_V1(
                token_id, token_outputs_amts, token_type)

        if selected_slp_coins:
            assert slp_op_return_msg

        return (selected_slp_coins, slp_op_return_msg)
    def burn_token(self, preview=False):
        unfrozen_token_qty = self.wallet.get_slp_token_balance(self.token_id_e.text(), self.main_window.config)[3]
        burn_amt = self.token_qty_e.get_amount()
        if burn_amt == None or burn_amt == 0:
            self.show_message(_("Invalid token quantity entered."))
            return
        if burn_amt > unfrozen_token_qty:
            self.show_message(_("Cannot burn more tokens than the unfrozen amount available."))
            return

        reply = QMessageBox.question(self, "Continue?", "Destroy " + self.token_qty_e.text() + " " + self.token_name.text() + " tokens?", QMessageBox.Yes, QMessageBox.No)
        if reply == QMessageBox.Yes:
            pass
        else:
            return

        outputs = []
        slp_coins = self.wallet.get_slp_utxos(
            self.token_id_e.text(),
            domain=None, exclude_frozen=True, confirmed_only=self.main_window.config.get('confirmed_only', False),
            slp_include_invalid=self.token_burn_invalid_cb.isChecked(), slp_include_baton=self.token_burn_baton_cb.isChecked())

        addr = self.wallet.get_unused_address(frozen_ok=False)
        if addr is None:
            if not self.wallet.is_deterministic():
                addr = self.wallet.get_receiving_address()
            else:
                addr = self.wallet.create_new_address(True)

        try:
            selected_slp_coins = []
            if burn_amt < unfrozen_token_qty:
                total_amt_added = 0
                for coin in slp_coins:
                    if coin['token_value'] != "MINT_BATON" and coin['token_validation_state'] == 1:
                        if coin['token_value'] >= burn_amt:
                            selected_slp_coins.append(coin)
                            total_amt_added+=coin['token_value']
                            break
                if total_amt_added < burn_amt:
                    for coin in slp_coins:
                        if coin['token_value'] != "MINT_BATON" and coin['token_validation_state'] == 1:
                            if total_amt_added < burn_amt:
                                selected_slp_coins.append(coin)
                                total_amt_added+=coin['token_value']
                if total_amt_added > burn_amt:
                    token_type = self.wallet.token_types[self.token_id_e.text()]['class']
                    slp_op_return_msg = buildSendOpReturnOutput_V1(self.token_id_e.text(), [total_amt_added - burn_amt], token_type)
                    outputs.append(slp_op_return_msg)
                    outputs.append((TYPE_ADDRESS, addr, 546))
            else:
                for coin in slp_coins:
                    if coin['token_value'] != "MINT_BATON" and coin['token_validation_state'] == 1:
                        selected_slp_coins.append(coin)

        except OPReturnTooLarge:
            self.show_message(_("Optional string text causiing OP_RETURN greater than 223 bytes."))
            return
        except Exception as e:
            traceback.print_exc(file=sys.stdout)
            self.show_message(str(e))
            return

        if self.token_burn_baton_cb.isChecked():
            for coin in slp_coins:
                if coin['token_value'] == "MINT_BATON" and coin['token_validation_state'] == 1:
                    selected_slp_coins.append(coin)

        if self.token_burn_invalid_cb.isChecked():
            for coin in slp_coins:
                if coin['token_validation_state'] != 1:
                    selected_slp_coins.append(coin)

        bch_change = sum(c['value'] for c in selected_slp_coins)
        outputs.append((TYPE_ADDRESS, addr, bch_change))

        coins = self.main_window.get_coins()
        fixed_fee = None

        try:
            tx = self.main_window.wallet.make_unsigned_transaction(coins, outputs, self.main_window.config, fixed_fee, None, mandatory_coins=selected_slp_coins)
        except NotEnoughFunds:
            self.show_message(_("Insufficient funds"))
            return
        except ExcessiveFee:
            self.show_message(_("Your fee is too high.  Max is 50 sat/byte."))
            return
        except BaseException as e:
            traceback.print_exc(file=sys.stdout)
            self.show_message(str(e))
            return

        if preview:
            show_transaction(tx, self.main_window, None, False, self, slp_coins_to_burn=selected_slp_coins)
            return

        msg = []

        if self.main_window.wallet.has_password():
            msg.append("")
            msg.append(_("Enter your password to proceed"))
            password = self.main_window.password_dialog('\n'.join(msg))
            if not password:
                return
        else:
            password = None

        tx_desc = None

        def sign_done(success):
            if success:
                if not tx.is_complete():
                    show_transaction(tx, self.main_window, None, False, self)
                    self.main_window.do_clear()
                else:
                    self.main_window.broadcast_transaction(tx, tx_desc)

        self.main_window.sign_tx_with_password(tx, sign_done, password, slp_coins_to_burn=selected_slp_coins)

        self.burn_button.setDisabled(True)
        self.close()
    def burn_token(self, preview=False, multisig_tx_to_sign=None):
        token_type = self.wallet.token_types[self.token_id_e.text()]['class']
        unfrozen_token_qty = self.wallet.get_slp_token_balance(
            self.token_id_e.text(), self.main_window.config)[3]
        desired_burn_amt = self.token_qty_e.get_amount()

        selected_slp_coins = []

        if desired_burn_amt == None or desired_burn_amt < 0:
            self.show_message(_("Enter a valid token quantity."))
            return
        elif desired_burn_amt > unfrozen_token_qty:
            self.show_message(
                _("Cannot burn a quantity greater than your unfrozen token balance."
                  ))
            return

        msg = "Destroy " + self.token_qty_e.text(
        ) + " " + self.token_name.text() + " tokens"
        if self.token_burn_baton_cb.isChecked():
            msg += " AND the MINTING BATON"
        msg += "?!?"
        reply = QMessageBox.question(self, "Continue?", msg, QMessageBox.Yes,
                                     QMessageBox.No)
        if reply == QMessageBox.Yes:
            pass
        else:
            return

        outputs = []

        addr = self.wallet.get_unused_address(frozen_ok=False)
        if addr is None:
            if not self.wallet.is_deterministic():
                addr = self.wallet.get_receiving_address()
            else:
                addr = self.wallet.create_new_address(True)

        try:
            slp_coins = self.wallet.get_slp_utxos(
                self.token_id_e.text(),
                domain=None,
                exclude_frozen=True,
                confirmed_only=self.main_window.config.get(
                    'confirmed_only', False),
                slp_include_invalid=
                False,  #self.token_burn_invalid_cb.isChecked(),
                slp_include_baton=self.token_burn_baton_cb.isChecked())
            if multisig_tx_to_sign is None:
                selected_slp_coins = []
                if desired_burn_amt < unfrozen_token_qty:
                    total_amt_added = 0
                    for coin in slp_coins:
                        if coin['token_value'] != "MINT_BATON" and coin[
                                'token_validation_state'] == 1:
                            if coin['token_value'] >= desired_burn_amt:
                                selected_slp_coins.append(coin)
                                total_amt_added += coin['token_value']
                                break
                    if total_amt_added < desired_burn_amt:
                        for coin in slp_coins:
                            if coin['token_value'] != "MINT_BATON" and coin[
                                    'token_validation_state'] == 1:
                                if total_amt_added < desired_burn_amt:
                                    selected_slp_coins.append(coin)
                                    total_amt_added += coin['token_value']
                    if total_amt_added > desired_burn_amt:
                        slp_op_return_msg = buildSendOpReturnOutput_V1(
                            self.token_id_e.text(),
                            [total_amt_added - desired_burn_amt], token_type)
                        outputs.append(slp_op_return_msg)
                        outputs.append((TYPE_ADDRESS, addr, 546))
                else:
                    for coin in slp_coins:
                        if coin['token_value'] != "MINT_BATON" and coin[
                                'token_validation_state'] == 1:
                            selected_slp_coins.append(coin)
            else:
                try:
                    slp_msg = SlpMessage.parseSlpOutputScript(
                        multisig_tx_to_sign.outputs()[0][1])
                except SlpParsingError:
                    slp_msg = None
                if slp_msg and slp_msg.op_return_fields[
                        'token_id_hex'] != self.token_id_e.text():
                    self.show_message(_("Token id in the imported transaction is not correct.")+\
                                            _("\n\nImported Token ID: ") + slp_msg.op_return_fields['token_id_hex'] + \
                                            _("\n\nDesired Token ID: ") + self.token_id_e.text())
                    return
                for txo in multisig_tx_to_sign.inputs():
                    addr = txo['address']
                    prev_out = txo['prevout_hash']
                    prev_n = txo['prevout_n']
                    slp_txo = None
                    try:
                        for coin in slp_coins:
                            if coin['prevout_hash'] == prev_out \
                                and coin['prevout_n'] == prev_n \
                                and coin['token_value'] != "MINT_BATON":
                                selected_slp_coins.append(coin)
                                total_burn_amt += coin['token_value']
                    except KeyError:
                        pass
                if slp_msg:
                    total_burn_amt -= sum(
                        slp_msg.op_return_fields['token_output'])
                if total_burn_amt > desired_burn_amt:
                    if slp_msg:
                        self.show_message(
                            _("Amount burned in transaction does not match the amount specified."
                              ))
                    else:
                        self.show_message(_("Amount burned in transaction does not match the amount specified.") + \
                                        _("\n\nMake sure the Token ID displayed in the Burn Tool dialog matches the token that you are trying to burn."))
                    return

        except OPReturnTooLarge:
            self.show_message(
                _("Optional string text causing OP_RETURN greater than 223 bytes."
                  ))
            return
        except Exception as e:
            traceback.print_exc(file=sys.stdout)
            self.show_message(str(e))
            return

        if self.token_burn_baton_cb.isChecked():
            for coin in slp_coins:
                if coin['token_value'] == "MINT_BATON" and coin[
                        'token_validation_state'] == 1:
                    selected_slp_coins.append(coin)

        # if self.token_burn_invalid_cb.isChecked():
        #     for coin in slp_coins:
        #         if coin['token_validation_state'] != 1:
        #             selected_slp_coins.append(coin)

        try:
            if multisig_tx_to_sign is None:
                bch_change = sum(c['value'] for c in selected_slp_coins)
                outputs.append((TYPE_ADDRESS, addr, bch_change))
                coins = self.main_window.get_coins()
                fixed_fee = None
                tx = self.main_window.wallet.make_unsigned_transaction(
                    coins,
                    outputs,
                    self.main_window.config,
                    fixed_fee,
                    None,
                    mandatory_coins=selected_slp_coins)
            else:
                tx = multisig_tx_to_sign

            # perform slp pre-flight check before signing (this check run here and also at signing)
            slp_preflight = SlpPreflightCheck.query(
                tx,
                selected_slp_coins=selected_slp_coins,
                amt_to_burn=desired_burn_amt)
            if not slp_preflight['ok']:
                raise Exception("slp pre-flight failed: %s" %
                                slp_preflight['invalid_reason'])

        except NotEnoughFunds:
            self.show_message(_("Insufficient funds"))
            return
        except ExcessiveFee:
            self.show_message(_("Your fee is too high.  Max is 50 sat/byte."))
            return
        except BaseException as e:
            traceback.print_exc(file=sys.stdout)
            self.show_message(str(e))
            return

        if preview:
            show_transaction(tx,
                             self.main_window,
                             None,
                             False,
                             self,
                             slp_coins_to_burn=selected_slp_coins,
                             slp_amt_to_burn=desired_burn_amt)
            return

        msg = []

        if self.main_window.wallet.has_password():
            msg.append("")
            msg.append(_("Enter your password to proceed"))
            password = self.main_window.password_dialog('\n'.join(msg))
            if not password:
                return
        else:
            password = None

        tx_desc = None

        def sign_done(success):
            if success:
                if not tx.is_complete():
                    show_transaction(tx, self.main_window, None, False, self)
                    self.main_window.do_clear()
                else:
                    self.main_window.broadcast_transaction(tx, tx_desc)

        self.main_window.sign_tx_with_password(
            tx,
            sign_done,
            password,
            slp_coins_to_burn=selected_slp_coins,
            slp_amt_to_burn=desired_burn_amt)

        self.burn_button.setDisabled(True)
        self.close()
    def calculate_postage_and_build_slp_msg(wallet, config, tokenId, po_data,
                                            send_amount):

        # determine the amount of postage to pay based on the token's rate and number of inputs we will sign
        weight = po_data["weight"]
        rate = None
        for stamp in po_data["stamps"]:
            if stamp["tokenId"] == tokenId:
                rate = stamp["rate"]

        if rate is None:
            raise Exception(
                "Post Office does not offer postage for tokenId: " + tokenId)

        # variables used for txn size estimation
        slpmsg_output_max_size = 8 + 1 + 73  # case where both postage and change are needed
        slpmsg_output_mid_size = slpmsg_output_max_size - 9  # case where no token change is not needed
        slpmsg_output_min_size = slpmsg_output_mid_size - 9  # case where no token or change are needed
        output_unit_size = 34  # p2pkh output size
        input_unit_size_ecdsa = 149  # approx. size needed for ecdsa signed input
        input_unit_size_schnorr = 141  # approx. size needed for schnorr signed input
        txn_overhead = 4 + 1 + 1 + 4  # txn version, input count varint, output count varint, timelock

        # determine number of stamps required in this while loop
        sats_diff_w_fee = 1  # controls entry into while loop
        stamp_count = -1  # will get updated to 0 stamps in first iteration
        while sats_diff_w_fee > 0:
            stamp_count += 1
            coins, _ = SlpCoinChooser.select_coins(
                wallet, tokenId, (send_amount + (rate * stamp_count)), config)

            output_dust_count = 1
            slpmsg_output_size = slpmsg_output_min_size
            postage_amt = rate * stamp_count
            total_coin_value = 0
            for coin in coins:
                total_coin_value += coin["token_value"]
                wallet.add_input_info(coin)
            change_amt = total_coin_value - send_amount - postage_amt

            if postage_amt > 0 and change_amt > 0:
                output_dust_count = 3
                slpmsg_output_size = slpmsg_output_max_size
            elif postage_amt > 0 or change_amt > 0:
                output_dust_count = 2
                slpmsg_output_size = slpmsg_output_mid_size

            txn_size_wo_stamps = txn_overhead + input_unit_size_ecdsa * len(
                coins
            ) + output_unit_size * output_dust_count + slpmsg_output_size

            # output cost differential (positive value means we need stamps)
            output_sats_diff = (output_dust_count * 546) - (len(coins) * 546)

            # fee cost differential (positive value means we need more stamps)
            fee_rate = 1
            sats_diff_w_fee = (txn_size_wo_stamps * fee_rate
                               ) + output_sats_diff - stamp_count * weight

        if output_dust_count == 1:
            amts = [send_amount]
            needs_postage = False
        elif output_dust_count == 2 and postage_amt > 0:
            amts = [send_amount, postage_amt]
            needs_postage = True
        elif output_dust_count == 2 and change_amt > 0:
            amts = [send_amount, change_amt]
            needs_postage = False
        elif output_dust_count == 3:
            amts = [send_amount, postage_amt, change_amt]
            needs_postage = True
        else:
            raise Exception("Unhandled exception")

        slp_output = buildSendOpReturnOutput_V1(tokenId, amts)

        return coins, slp_output, needs_postage, postage_amt
    def prepare_nft_parent(self, preview=False):

        self.show_message(
            "An initial preparation transaction is required before a new NFT can be created. This ensures only 1 parent token is burned in the NFT Genesis transaction.\n\nAfter this is transaction is broadcast you can proceed to fill out the NFT details and then click 'Create NFT'."
        )

        # IMPORTANT: set wallet.send_slpTokenId to None to guard tokens during this transaction
        self.main_window.token_type_combo.setCurrentIndex(0)
        assert self.main_window.slp_token_id == None

        coins = self.main_window.get_coins()
        fee = None

        try:
            selected_coin = None
            nft_parent_coins = self.main_window.wallet.get_slp_utxos(
                self.nft_parent_id,
                domain=None,
                exclude_frozen=True,
                confirmed_only=self.main_window.config.get(
                    'confirmed_only', False),
                slp_include_invalid=False,
                slp_include_baton=False)
            for coin in nft_parent_coins:
                if coin['token_value'] > 1:
                    selected_coin = coin
                    break

            if selected_coin['token_value'] < 19:
                slp_qtys = [1] * selected_coin['token_value']
            elif selected_coin['token_value'] >= 19:
                slp_qtys = [1] * 18
                slp_qtys.append(selected_coin['token_value'] - 18)
            outputs = []
            try:
                slp_op_return_msg = buildSendOpReturnOutput_V1(
                    self.nft_parent_id, slp_qtys, token_type=129)
                outputs.append(slp_op_return_msg)
            except OPReturnTooLarge:
                self.show_message(
                    _("Optional string text causiing OP_RETURN greater than 223 bytes."
                      ))
                return
            except Exception as e:
                traceback.print_exc(file=sys.stdout)
                self.show_message(str(e))
                return
            try:
                addr = self.parse_address(self.token_pay_to_e.text())
                for i in slp_qtys:
                    outputs.append((TYPE_ADDRESS, addr, 546))
            except:
                self.show_message(
                    _("Must have Receiver Address in simpleledger format."))
                return
            if selected_coin:
                tx = self.main_window.wallet.make_unsigned_transaction(
                    coins,
                    outputs,
                    self.main_window.config,
                    fee,
                    None,
                    mandatory_coins=[selected_coin])
            else:
                self.show_message(
                    _("Unable to select a parent coin to prepare."))
                return
        except NotEnoughFunds:
            self.show_message(_("Insufficient funds"))
            return
        except ExcessiveFee:
            self.show_message(_("Your fee is too high.  Max is 50 sat/byte."))
            return
        except BaseException as e:
            traceback.print_exc(file=sys.stdout)
            self.show_message(str(e))
            return
        if preview:
            show_transaction(tx, self.main_window, None, False, self)
            return

        msg = []

        if self.main_window.wallet.has_password():
            msg.append("")
            msg.append(_("Enter your password to proceed"))
            password = self.main_window.password_dialog('\n'.join(msg))
            if not password:
                return
        else:
            password = None
        tx_desc = None

        def sign_done(success):
            if success:
                if not tx.is_complete():
                    show_transaction(tx, self.main_window, None, False, self)
                    self.main_window.do_clear()
                else:
                    token_id = tx.txid()
                    if self.token_name_e.text() == '':
                        wallet_name = tx.txid()[0:5]
                    else:
                        wallet_name = self.token_name_e.text()[0:20]
                    # Check for duplication error
                    d = self.wallet.token_types.get(token_id)
                    for tid, d in self.wallet.token_types.items():
                        if d['name'] == wallet_name and tid != token_id:
                            wallet_name = wallet_name + "-" + token_id[:3]
                            break
                    self.broadcast_transaction(tx,
                                               self.token_name_e.text(),
                                               wallet_name,
                                               is_nft_prep=True)
                    self.token_name_e.setDisabled(False)
                    self.token_ticker_e.setDisabled(False)
                    self.token_url_e.setDisabled(False)
                    self.token_dochash_e.setDisabled(False)
                    self.token_pay_to_e.setDisabled(False)
                    self.token_baton_to_e.setDisabled(False)
                    self.warn1.setHidden(True)
                    self.warn2.setHidden(True)
                    self.warn_msg.setHidden(True)

        self.sign_tx_with_password(tx, sign_done, password)