コード例 #1
0
    def test_wallet_multisig_2of2_with_single_key(self):
        if os.path.isfile(DATABASEFILE_UNITTESTS):
            os.remove(DATABASEFILE_UNITTESTS)
        keys = [
            HDKey(network='bitcoinlib_test'),
            HDKey(network='bitcoinlib_test', key_type='single')
        ]
        key_list = [keys[0], keys[1].public()]

        wl = HDWallet.create_multisig('multisig_expk2',
                                      key_list,
                                      sigs_required=2,
                                      network='bitcoinlib_test',
                                      databasefile=DATABASEFILE_UNITTESTS)
        wl.new_key()
        wl.new_key()
        wl.new_key_change()
        wl.utxos_update()

        self.assertEqual(wl.keys()[0].name, 'Multisig Key 8/7')
        self.assertEqual(wl.keys()[1].name, 'Multisig Key 10/7')
        self.assertEqual(wl.keys()[2].name, 'Multisig Key 12/7')

        t = wl.transaction_create(
            [(HDKey(network='bitcoinlib_test').key.address(), 6400000)],
            min_confirms=0)
        t = wl.transaction_sign(t, keys[1])
        self.assertEqual(wl.transaction_send(t),
                         'succesfull_test_sendrawtransaction')
コード例 #2
0
ファイル: test_wallets.py プロジェクト: ydxt25/bitcoinlib
    def test_wallet_key_import_and_sign_multisig(self):
        if os.path.isfile(DATABASEFILE_UNITTESTS):
            os.remove(DATABASEFILE_UNITTESTS)
        network = 'bitcoinlib_test'
        words = 'square innocent drama'
        seed = Mnemonic().to_seed(words, 'password')
        hdkey = HDKey.from_seed(seed, network=network)
        hdkey.key_type = 'single'

        key_list = [
            HDKey(network=network).account_multisig_key().public(),
            HDKey(network=network),
            hdkey.public()
        ]
        wallet = HDWallet.create_multisig('Multisig-2-of-3-example',
                                          key_list,
                                          2,
                                          sort_keys=True,
                                          network=network,
                                          databasefile=DATABASEFILE_UNITTESTS)
        wallet.new_key()
        wallet.utxos_update()
        wallet.import_key(hdkey)
        wt = wallet.send_to('n2eMqTT929pb1RDNuqEnxdaLau1rxy3efi', 10000000)
        self.assertIsNone(wt.error)
コード例 #3
0
ファイル: test_wallets.py プロジェクト: unoffices/bitcoinlib
    def test_wallet_multisig_sign_with_external_single_key(self):
        if os.path.isfile(DATABASEFILE_UNITTESTS):
            os.remove(DATABASEFILE_UNITTESTS)
        NETWORK = 'bitcoinlib_test'
        words = 'square innocent drama'
        seed = Mnemonic().to_seed(words, 'password')
        hdkey = HDKey.from_seed(seed, network=NETWORK)
        hdkey.key_type = 'single'

        key_list = [
            HDKey(network=NETWORK).account_multisig_key().public(),
            HDKey(network=NETWORK),
            hdkey.public()
        ]
        wallet = HDWallet.create_multisig('Multisig-2-of-3-example',
                                          key_list,
                                          2,
                                          network=NETWORK,
                                          databasefile=DATABASEFILE_UNITTESTS)
        wallet.new_key()
        wallet.utxos_update()
        res = wallet.send_to('n2eMqTT929pb1RDNuqEnxdaLau1rxy3efi', 10000000)
        t = res['transaction'].raw_hex()
        t2 = wallet.transaction_import(t)
        self.assertFalse(t2.verify())
        t2 = wallet.transaction_sign(t2, hdkey)
        self.assertTrue(t2.verify())
コード例 #4
0
    def test_transactions_multisig_signature_redeemscript_mixup(self):
        pk1 = HDKey(
            'tprv8ZgxMBicQKsPen95zTdorkDGPi4jHy9xBf4TdVxrB1wTJgSKCZbHpWhmaTGoRXHj2dJRcJQhRkV22Mz3uhg9nThjGLA'
            'JKzrPuZXPmFUgQ42')
        pk2 = HDKey(
            'tprv8ZgxMBicQKsPdhv4GxyNcfNK1Wka7QEnQ2c8DNdRL5z3hzf7ufUYNW14fgArjFvLtyg5xmPrkpx6oGBo2dquPf5inH6'
            'Jg6h2D89nsQdY8Ga')
        redeemscript = b'522103b008ee001282efb523f68d494896f3072903e03b3fb91d16713c56bf79693a382102d43dcc8a5db03172ba' \
                       b'95c345bb2d478654853f311dc4b1cbd313e5a327f0e3ba52ae'

        # Create 2-of-2 multisig transaction with 1 input and 1 output
        t = Transaction(network='testnet')
        t.add_input(
            'a2c226037d73022ea35af9609c717d98785906ff8b71818cd4095a12872795e7',
            1, [pk1.key.public_byte, pk2.key.public_byte],
            script_type='p2sh_multisig',
            sigs_required=2)
        t.add_output(900000, '2NEgmZU64NjiZsxPULekrFcqdS7YwvYh24r')

        # Sign with private key and verify
        t.sign(pk1.private_byte)
        t.sign(pk2.private_byte)
        self.assertTrue(t.verify())

        # Now deserialize and check if redeemscript is still the same
        dt = transaction_deserialize(t.raw_hex(), network='testnet')
        self.assertEqual(binascii.hexlify(dt[0][0].redeemscript), redeemscript)
コード例 #5
0
    def test_transactions_sign_multiple_inputs(self):
        # Two private keys with 1 UTXO on the blockchain each
        wif1 = 'xprvA3PZhxgsb5cogy52pm8eJf21gW2epoetxdCZxpmBWddViHmB7wgR4apQVxRHmyngapZ14pBzWSCP6sztWn8EaMmnwZaj' \
               'fs7oS6rZDYdnrwh'
        wif2 = 'xprvA3PZhxgsb5cojKHWdGGFBNut51QbAe5arWb7s7cJ9cT6zThQJFvYKKZDcmFirWJVVHgRYzqLc9XnuDMrP3Qwy8sK8Zu5' \
               'MisgvXVtGdwDhrH'

        # Create inputs with a UTXO with 2 unspent outputs which corresponds to this private keys
        utxo_hash = '0177ac29fa8b2960051321c730c6f15017503aa5b9c1dd2d61e7286e366fbaba'
        pk1 = HDKey(wif1)
        pk2 = HDKey(wif2)
        input1 = Input(prev_hash=utxo_hash,
                       output_index=0,
                       keys=pk1.public_byte,
                       tid=0)
        input2 = Input(prev_hash=utxo_hash,
                       output_index=1,
                       keys=pk2.public_byte,
                       tid=1)

        # Create a transaction with 2 inputs, and add 2 outputs below
        osm_address = '1J3pt9koWJZTo2jarg98RL89iJqff9Kobp'
        change_address = '1Ht9iDJ3FjwweQNuj451QVL6RAP5qxadFb'
        output1 = Output(amount=900000, address=osm_address)
        output2 = Output(amount=150000, address=change_address)
        t = Transaction(inputs=[input1, input2], outputs=[output1, output2])

        # Sign the inputs and verify
        # See txid 1ec28c925df0079ead9976d38165909ccb3580a428ce069ee13e63879df0c2fc
        t.sign(pk1.private_byte, 0)
        t.sign(pk2.private_byte, 1)
        self.assertTrue(t.verify())
コード例 #6
0
    def test_wallet_multisig_reopen_wallet(self):

        def _open_all_wallets():
            wl1 = wallet_create_or_open_multisig(
                'multisigmulticur1_tst', sigs_required=2, network=network,
                databasefile=DATABASEFILE_UNITTESTS,
                key_list=[pk1, pk2.account_multisig_key().wif_public(), pk3.account_multisig_key().wif_public()])
            wl2 = wallet_create_or_open_multisig(
                'multisigmulticur2_tst', sigs_required=2, network=network,
                databasefile=DATABASEFILE_UNITTESTS,
                key_list=[pk1.account_multisig_key().wif_public(), pk2, pk3.account_multisig_key().wif_public()])
            wl3 = wallet_create_or_open_multisig(
                'multisigmulticur3_tst', sigs_required=2, network=network,
                databasefile=DATABASEFILE_UNITTESTS,
                key_list=[pk1.account_multisig_key().wif_public(), pk2.account_multisig_key().wif_public(), pk3])
            return wl1, wl2, wl3

        if os.path.isfile(DATABASEFILE_UNITTESTS):
            os.remove(DATABASEFILE_UNITTESTS)
        network = 'litecoin'
        phrase1 = 'shop cloth bench traffic vintage security hour engage omit almost episode fragile'
        phrase2 = 'exclude twice mention orchard grit ignore display shine cheap exercise same apart'
        phrase3 = 'citizen obscure tribe index little welcome deer wine exile possible pizza adjust'
        pk1 = HDKey.from_passphrase(phrase1, network=network)
        pk2 = HDKey.from_passphrase(phrase2, network=network)
        pk3 = HDKey.from_passphrase(phrase3, network=network)
        wallets = _open_all_wallets()
        for wlt in wallets:
            self.assertEqual(wlt.get_key().address, '354bZpUpeaUEwsRn5Le5BymTvqPHf9jZkS')
        del wallets
        wallets2 = _open_all_wallets()
        for wlt in wallets2:
            self.assertEqual(wlt.get_key().address, '354bZpUpeaUEwsRn5Le5BymTvqPHf9jZkS')
            wlt._session.close_all()
コード例 #7
0
    def test_wallet_multisig_2of2_with_single_key(self):
        if os.path.isfile(DATABASEFILE_UNITTESTS):
            os.remove(DATABASEFILE_UNITTESTS)
        keys = [
            HDKey(network='bitcoinlib_test'),
            HDKey(network='bitcoinlib_test', key_type='single')
        ]
        key_list = [keys[0], keys[1].public()]

        wl = HDWallet.create_multisig('multisig_expk2', key_list, sigs_required=2, network='bitcoinlib_test',
                                      databasefile=DATABASEFILE_UNITTESTS, sort_keys=False)
        wl.new_key()
        wl.new_key()
        wl.new_key_change()
        wl.utxos_update()
        key_names = [k.name for k in wl.keys(is_active=False)]
        self.assertListEqual(key_names, ['Multisig Key 8/7', 'Multisig Key 10/7', 'Multisig Key 12/7'])

        t = wl.transaction_create([(HDKey(network='bitcoinlib_test').key.address(), 6400000)], min_confirms=0)
        t.sign(keys[1])
        t.send()
        self.assertIsNone(t.error)

        key_names_active = [k.name for k in wl.keys(is_active=False)]
        self.assertEqual(key_names_active,
                         ['Multisig Key 8/7', 'Multisig Key 10/7', 'Multisig Key 12/7', 'Multisig Key 14/7'])
コード例 #8
0
    def test_wallet_multisig_2of2(self):
        """
        Create 2 cosigner wallets with 1 own private key a public key from other cosigner
        Then create and sign transaction if first wallet, import and sign it in second wallet
        and verify created transaction.

        """
        if os.path.isfile(DATABASEFILE_UNITTESTS):
            os.remove(DATABASEFILE_UNITTESTS)

        keys = [
            HDKey('YXscyqNJ5YK411nwB4wzazXjJn9L9iLAR1zEMFcpLipDA25rZregBGgwXmprsvQLeQAsuTvemtbCWR1AHaPv2qmvkartoiFUU6'
                  'qu1uafT2FETtXT', network='bitcoinlib_test'),
            HDKey('YXscyqNJ5YK411nwB4EyGbNZo9eQSUWb64vAFKHt7E2LYnbmoNz8Gyjs6xc7iYAudcnkgf127NPnaanuUgyRngAiwYBcXKGsSJ'
                  'wadGhxByT2MnLd', network='bitcoinlib_test')]

        msw1 = HDWallet.create_multisig('msw1', [keys[0], keys[1].subkey_for_path("m/45'/9999999'/0'").wif_public()],
                                        network='bitcoinlib_test', sort_keys=False, sigs_required=2,
                                        databasefile=DATABASEFILE_UNITTESTS)
        msw2 = HDWallet.create_multisig('msw2', [keys[0].subkey_for_path("m/45'/9999999'/0'").wif_public(), keys[1]],
                                        network='bitcoinlib_test', sort_keys=False, sigs_required=2,
                                        databasefile=DATABASEFILE_UNITTESTS)
        msw1.new_key()
        msw2.new_key()
        msw1.utxos_update()
        msw2.utxos_update()
        utxos = msw1.utxos()
        output_arr = [('21KnydRNSmqAf8Py74mMiwRXYHGxW27zyDu', utxos[0]['value'] - 50000)]
        input_arr = [(utxos[0]['tx_hash'], utxos[0]['output_n'], utxos[0]['key_id'], utxos[0]['value'])]
        t = msw1.transaction_create(output_arr, input_arr, fee=50000)
        t.sign()
        t2 = msw2.transaction_import(t)
        t2.sign()
        self.assertTrue(t2.verify())
コード例 #9
0
    def test_wallet_import_private_for_known_public(self):
        hdkey = HDKey(
            'xprv9s21ZrQH143K2noEZoqGHnaDDLjrnFpis8jm7NWDhkWuNNCqMupGSy7PMYtGL9jvdTY7Nx3GZ6UZ9C52nebwbYXK73imaPUK24'
            'dZJtGZhGd')
        with HDWallet.create('public-private', hdkey.account_key().public(), databasefile=DATABASEFILE_UNITTESTS) \
                as wlt:
            wlt.import_key(hdkey)

            self.assertListEqual([k.path for k in wlt.keys()], ["m/44'/0'/0'", 'm', "m/44'", "m/44'/0'"])
            self.assertEqual(wlt.new_account().address, '16m3JAtQjHbmEZd8uYTyKebvrxh2RsFHB')
            self.assertEqual(wlt.new_key().address, '1P8BTrsBn8DKGQq7nSWPiEiUDgiG8sW1kf')
コード例 #10
0
ファイル: test_wallets.py プロジェクト: ydxt25/bitcoinlib
    def _multisig_test(sigs_required, number_of_sigs, sort_keys, network):
        # Create Keys
        key_dict = {}
        for key_id in range(number_of_sigs):
            key_dict[key_id] = HDKey(network=network)
        random_output_address = HDKey(network=network).key.address()

        # Create wallets with 1 private key each
        wallet_dict = {}
        wallet_keys = {}
        for wallet_id in range(number_of_sigs):
            wallet_name = 'multisig-%d' % wallet_id
            key_list = []
            for key_id in key_dict:
                if key_id == wallet_id:
                    key_list.append(key_dict[key_id])
                else:
                    key_list.append(key_dict[key_id].subkey_for_path(
                        "m/45'/%d'/0'" %
                        Network(network).bip44_cointype).wif_public())
            wallet_dict[wallet_id] = HDWallet.create_multisig(
                wallet_name,
                key_list,
                sigs_required=sigs_required,
                network=network,
                sort_keys=sort_keys,
                databasefile=DATABASEFILE_UNITTESTS)
            wallet_keys[wallet_id] = wallet_dict[wallet_id].new_key()
            wallet_dict[wallet_id].utxos_update()

        # Create transaction in one random wallet
        wallet_ids = [i for i in range(0, number_of_sigs)]
        shuffle(wallet_ids)
        transaction_fee = 50000
        wallet_id = wallet_ids.pop()
        wlt = wallet_dict[wallet_id]
        utxos = wlt.utxos()
        output_arr = [(random_output_address,
                       utxos[0]['value'] - transaction_fee)]
        input_arr = [(utxos[0]['tx_hash'], utxos[0]['output_n'],
                      utxos[0]['key_id'], utxos[0]['value'])]
        t = wlt.transaction_create(output_arr,
                                   input_arr,
                                   transaction_fee=transaction_fee)
        t.sign()
        n_signs = 1

        # Sign transaction with other wallets until required number of signatures is reached
        while wallet_ids and n_signs < sigs_required:
            wallet_id = wallet_ids.pop()
            t = wallet_dict[wallet_id].transaction_import(t)
            t.sign()
            n_signs += 1
        return t
コード例 #11
0
ファイル: test_wallets.py プロジェクト: ydxt25/bitcoinlib
    def test_wallet_multisig_2of2_different_database(self):
        """
        Same unittest as before (test_wallet_multisig_sign_2_different_wallets) but now with 2
        separate databases to check for database inteference.

        """
        if os.path.isfile(DATABASEFILE_UNITTESTS):
            os.remove(DATABASEFILE_UNITTESTS)
        if os.path.isfile(DATABASEFILE_UNITTESTS_2):
            os.remove(DATABASEFILE_UNITTESTS_2)

        keys = [
            HDKey(
                'YXscyqNJ5YK411nwB4wzazXjJn9L9iLAR1zEMFcpLipDA25rZregBGgwXmprsvQLeQAsuTvemtbCWR1AHaPv2qmvkartoiFUU6'
                'qu1uafT2FETtXT',
                network='bitcoinlib_test'),
            HDKey(
                'YXscyqNJ5YK411nwB4EyGbNZo9eQSUWb64vAFKHt7E2LYnbmoNz8Gyjs6xc7iYAudcnkgf127NPnaanuUgyRngAiwYBcXKGsSJ'
                'wadGhxByT2MnLd',
                network='bitcoinlib_test')
        ]

        msw1 = HDWallet.create_multisig('msw1', [
            keys[0], keys[1].subkey_for_path("m/45'/9999999'/0'").wif_public()
        ],
                                        network='bitcoinlib_test',
                                        sort_keys=False,
                                        sigs_required=2,
                                        databasefile=DATABASEFILE_UNITTESTS)
        msw2 = HDWallet.create_multisig('msw2', [
            keys[0].subkey_for_path("m/45'/9999999'/0'").wif_public(), keys[1]
        ],
                                        network='bitcoinlib_test',
                                        sort_keys=False,
                                        sigs_required=2,
                                        databasefile=DATABASEFILE_UNITTESTS_2)
        msw1.new_key()
        msw2.new_key()
        msw1.utxos_update()
        msw2.utxos_update()
        utxos = msw1.utxos()
        output_arr = [('21KnydRNSmqAf8Py74mMiwRXYHGxW27zyDu',
                       utxos[0]['value'] - 50000)]
        input_arr = [(utxos[0]['tx_hash'], utxos[0]['output_n'],
                      utxos[0]['key_id'], utxos[0]['value'])]
        t = msw1.transaction_create(output_arr,
                                    input_arr,
                                    transaction_fee=50000)
        t.sign()
        t2 = msw2.transaction_import(t)
        t2.sign()
        t2.send()
        self.assertIsNone(t2.error)
コード例 #12
0
ファイル: cli_wallet.py プロジェクト: AustEcon/bitcoinlib
def create_wallet(wallet_name, args, databasefile):
    if args.network is None:
        args.network = DEFAULT_NETWORK
    print("\nCREATE wallet '%s' (%s network)" % (wallet_name, args.network))
    if args.create_multisig:
        if not isinstance(args.create_multisig, list) or len(args.create_multisig) < 2:
            clw_exit("Please enter multisig creation parameter in the following format: "
                     "<number-of-signatures> <number-of-signatures-required> "
                     "<key-0> <key-1> [<key-2> ... <key-n>]")
        try:
            sigs_total = int(args.create_multisig[0])
        except ValueError:
            clw_exit("Number of total signatures (first argument) must be a numeric value. %s" %
                     args.create_multisig[0])
        try:
            sigs_required = int(args.create_multisig[1])
        except ValueError:
            clw_exit("Number of signatures required (second argument) must be a numeric value. %s" %
                     args.create_multisig[1])
        key_list = args.create_multisig[2:]
        keys_missing = sigs_total - len(key_list)
        assert(keys_missing >= 0)
        if keys_missing:
            print("Not all keys provided, creating %d additional keys" % keys_missing)
            for _ in range(keys_missing):
                passphrase = get_passphrase(args)
                passphrase = ' '.join(passphrase)
                seed = binascii.hexlify(Mnemonic().to_seed(passphrase))
                key_list.append(HDKey().from_seed(seed, network=args.network))
        return HDWallet.create_multisig(name=wallet_name, keys=key_list, sigs_required=sigs_required,
                                        network=args.network, databasefile=databasefile, sort_keys=True,
                                        witness_type=args.witness_type)
    elif args.create_from_key:
        return HDWallet.create(name=wallet_name, network=args.network, keys=args.create_from_key,
                               databasefile=databasefile, witness_type=args.witness_type)
    else:
        passphrase = args.passphrase
        if passphrase is None:
            passphrase = get_passphrase(args)
        elif not passphrase:
            passphrase = input("Enter Passphrase: ")
        if not isinstance(passphrase, list):
            passphrase = passphrase.split(' ')
        elif len(passphrase) == 1:
            passphrase = passphrase[0].split(' ')
        if len(passphrase) < 12:
            clw_exit("Please specify passphrase with 12 words or more")
        passphrase = ' '.join(passphrase)
        seed = binascii.hexlify(Mnemonic().to_seed(passphrase))
        hdkey = HDKey().from_seed(seed, network=args.network)
        return HDWallet.create(name=wallet_name, network=args.network, keys=hdkey, witness_type=args.witness_type,
                               databasefile=databasefile)
コード例 #13
0
ファイル: cli-wallet.py プロジェクト: leafyoung/bitcoinlib
def create_wallet(wallet_name, args, databasefile):
    print("\nCREATE wallet '%s' (%s network)" % (wallet_name, args.network))
    if args.create_multisig:
        if not isinstance(args.create_multisig,
                          list) or len(args.create_multisig) < 3:
            clw_exit(
                "Please enter multisig creation parameter in the following format: "
                "<number-of-signatures-required> <key-0> <key-1> [<key-2> ... <key-n>]"
            )
        try:
            sigs_required = int(args.create_multisig[0])
        except ValueError:
            clw_exit(
                "Number of signatures required (first argument) must be a numeric value. %s"
                % args.create_multisig[0])
        key_list = args.create_multisig[1:]
        return HDWallet.create_multisig(name=wallet_name,
                                        key_list=key_list,
                                        sigs_required=sigs_required,
                                        network=args.network,
                                        databasefile=databasefile)
    else:
        passphrase = args.passphrase
        if passphrase is None:
            inp_passphrase = Mnemonic('english').generate(
                args.passphrase_strength)
            print("\nYour mnemonic private key sentence is: %s" %
                  inp_passphrase)
            print(
                "\nPlease write down on paper and backup. With this key you can restore your wallet and all keys"
            )
            passphrase = inp_passphrase.split(' ')
            inp = input(
                "\nType 'yes' if you understood and wrote down your key: ")
            if inp not in ['yes', 'Yes', 'YES']:
                clw_exit("Exiting...")
        elif not passphrase:
            passphrase = input("Enter Passphrase: ")
        if not isinstance(passphrase, list):
            passphrase = passphrase.split(' ')
        elif len(passphrase) == 1:
            passphrase = passphrase[0].split(' ')
        if len(passphrase) < 12:
            clw_exit("Please specify passphrase with 12 words or more")
        passphrase = ' '.join(passphrase)
        seed = binascii.hexlify(Mnemonic().to_seed(passphrase))
        hdkey = HDKey().from_seed(seed, network=args.network)
        return HDWallet.create(name=wallet_name,
                               network=args.network,
                               key=hdkey.wif(),
                               databasefile=databasefile)
コード例 #14
0
 def test_wallet_multisig_network_mixups(self):
     if os.path.isfile(DATABASEFILE_UNITTESTS):
         os.remove(DATABASEFILE_UNITTESTS)
     network = 'litecoin_testnet'
     phrase1 = 'shop cloth bench traffic vintage security hour engage omit almost episode fragile'
     phrase2 = 'exclude twice mention orchard grit ignore display shine cheap exercise same apart'
     phrase3 = 'citizen obscure tribe index little welcome deer wine exile possible pizza adjust'
     pk2 = HDKey.from_passphrase(phrase2, network=network)
     pk3 = HDKey.from_passphrase(phrase3, network=network)
     wlt = wallet_create_or_open_multisig(
         'multisig_network_mixups', sigs_required=2, network=network, databasefile=DATABASEFILE_UNITTESTS,
         key_list=[phrase1, pk2.account_multisig_key().wif_public(), pk3.account_multisig_key().wif_public()])
     self.assertEqual(wlt.get_key().address, 'QeBprfDJNadgqJV4R5d7e9i6duVK8HFgAN')
     self.assertEqual(wlt.get_key().network.network_name, network)
コード例 #15
0
def create_wallet(wallet_name, args, databasefile):
    if args.network is None:
        args.network = DEFAULT_NETWORK
    print("\nCREATE wallet '%s' (%s network)" % (wallet_name, args.network))
    if args.create_multisig:
        if not isinstance(args.create_multisig,
                          list) or len(args.create_multisig) < 3:
            clw_exit(
                "Please enter multisig creation parameter in the following format: "
                "<number-of-signatures-required> <key-0> <key-1> [<key-2> ... <key-n>]"
            )
        try:
            sigs_required = int(args.create_multisig[0])
        except ValueError:
            clw_exit(
                "Number of signatures required (first argument) must be a numeric value. %s"
                % args.create_multisig[0])
        key_list = args.create_multisig[1:]
        return HDWallet.create_multisig(name=wallet_name,
                                        key_list=key_list,
                                        sigs_required=sigs_required,
                                        network=args.network,
                                        databasefile=databasefile,
                                        sort_keys=True)
    elif args.create_from_key:
        return HDWallet.create(name=wallet_name,
                               network=args.network,
                               key=args.create_from_key,
                               databasefile=databasefile)
    else:
        passphrase = args.passphrase
        if passphrase is None:
            passphrase = get_passphrase(args)
        elif not passphrase:
            passphrase = input("Enter Passphrase: ")
        if not isinstance(passphrase, list):
            passphrase = passphrase.split(' ')
        elif len(passphrase) == 1:
            passphrase = passphrase[0].split(' ')
        if len(passphrase) < 12:
            clw_exit("Please specify passphrase with 12 words or more")
        passphrase = ' '.join(passphrase)
        seed = binascii.hexlify(Mnemonic().to_seed(passphrase))
        hdkey = HDKey().from_seed(seed, network=args.network)
        return HDWallet.create(name=wallet_name,
                               network=args.network,
                               key=hdkey.wif(),
                               databasefile=databasefile)
コード例 #16
0
    def __init__(self, *args, **kwargs):

        self.project_name = os.environ.get('PROJECT_NAME')
        self.deployment_name = os.environ.get('DEPLOYMENT_NAME')

        # Initialize bitcoin wallet
        xpub_wif = os.environ.get('HDKEY_XPUB_WIF', None)
        if xpub_wif is None:
            raise NoXPUBFoud
        try:
            xpub = HDKey(xpub_wif)
            self.wallet = Wallet.create("Wallet", keys=xpub, network='bitcoin', witness_type='segwit')
        except Exception as e:
            raise e

        # Initialize Ubiops Client
        ubiops_api_token = os.environ.get('UBIOPS_API_TOKEN', None)
        internal_ubiops_api_host = os.environ.get('INT_API_URL')

        ubiops_conf = ubiops.Configuration(
            host=internal_ubiops_api_host,
            api_key={'Authorization': 'Token {}'.format(ubiops_api_token)},
        )
        client = ubiops.ApiClient(ubiops_conf)
        self.ubiops_api = ubiops.api.CoreApi(client)

        environment_variables = self.ubiops_api.deployment_environment_variables_list(self.project_name, self.deployment_name)

        self.last_used_path_index = os.environ.get('LAST_USED_PATH_INDEX', '0/0')
        self.last_used_path_index_env = None
        for env in environment_variables:
            if env.name == 'LAST_USED_PATH_INDEX':
                self.last_used_path_index_env = env

        print("Wallet initialized successfuly.")
コード例 #17
0
def key(network, key):
    network_name = network_code_translation[network]
    try:
        k = HDKey(key, network=network_name)
    except Exception as e:
        flash(_('Invalid key: %s' % e), category='error')
        return redirect(url_for('main.index'))

    if k.is_private:
        flash(_(
            'Never post your private key online. Only use this for test keys or in an offline environment!'
        ),
              category='error')
    return render_template('explorer/key.html',
                           title=_('Key'),
                           subtitle=k.wif(),
                           key=k,
                           network=network)
コード例 #18
0
 def setUp(self):
     self.pk1 = HDKey(
         'tprv8ZgxMBicQKsPen95zTdorkDGPi4jHy9xBf4TdVxrB1wTJgSKCZbHpWhmaTGoRXHj2dJRcJQhRkV22Mz3uh'
         'g9nThjGLAJKzrPuZXPmFUgQ42')
     self.pk2 = HDKey(
         'tprv8ZgxMBicQKsPdhv4GxyNcfNK1Wka7QEnQ2c8DNdRL5z3hzf7ufUYNW14fgArjFvLtyg5xmPrkpx6oGBo2'
         'dquPf5inH6Jg6h2D89nsQdY8Ga')
     self.pk3 = HDKey(
         'tprv8ZgxMBicQKsPedw6MqKGBhVtpDTMpGqdUUrkurgvpAZxoEpn2SVJbUtArig6cnpxenVWs42FRB3wp5Lim'
         'CAVsjLKHmAK1hB1fYJ8aUyzQeH')
     self.pk4 = HDKey(
         'tprv8ZgxMBicQKsPefyc4C5BZwKRtBoNS8WA1to31B6QCxrrXY83FnWVALo3YKNuuisqbN9FUM245nZnXEQbf'
         'uEemfBXy7CLD6abaXx24PotyQY')
     self.pk5 = HDKey(
         'tprv8ZgxMBicQKsPdbyo59MRWqjXq3tTCS4PgJuFzJZvp8dBZz5HpQBw994LDS7ig8rsJcZwq6r3LghBeb82L'
         'iYu6rL35dm3XiMMJjNoY8d6pqN')
     self.utxo_tbtcleft = 740000
     self.utxo_prev_tx = 'f601e39f6b99b64fc2e98beb706ec7f14d114db7e61722c0313b0048df49453e'
     self.utxo_output_n = 1
コード例 #19
0
ファイル: mnemonic_test.py プロジェクト: 1200wd/bitcoinlib
 def _check_list(self, language, vectors):
     mnemo = Mnemonic(language)
     for v in vectors:
         if v[0]:
             phrase = mnemo.to_mnemonic(v[0])
         else:
             phrase = v[1]
         seed = change_base(mnemo.to_seed(phrase, v[4]), 256, 16)
         print("Test %s => %s" % (v[0], phrase))
         self.assertEqual(v[1], phrase)
         self.assertEqual(v[2], seed)
         k = HDKey.from_seed(seed)
         self.assertEqual(k.extended_wif(), v[3])
コード例 #20
0
 def _check_list(self, language, vectors):
     mnemo = Mnemonic(language)
     for v in vectors:
         if v[0]:
             phrase = mnemo.to_mnemonic(v[0], check_on_curve=False)
         else:
             phrase = v[1]
         seed = change_base(mnemo.to_seed(phrase, v[4], validate=False), 256, 16)
         # print("Test %s => %s" % (v[0], phrase))
         self.assertEqual(v[1], phrase)
         self.assertEqual(v[2], seed)
         k = HDKey.from_seed(seed)
         self.assertEqual(k.wif(is_private=True), v[3])
コード例 #21
0
 def _check_list(self, language, vectors):
     mnemo = Mnemonic(language)
     for v in vectors:
         if v[0]:
             phrase = mnemo.to_mnemonic(v[0])
         else:
             phrase = v[1]
         seed = change_base(mnemo.to_seed(phrase, v[4]), 256, 16)
         print("Test %s => %s" % (v[0], phrase))
         self.assertEqual(v[1], phrase)
         self.assertEqual(v[2], seed)
         k = HDKey.from_seed(seed)
         self.assertEqual(k.wif(), v[3])
コード例 #22
0
 def test_wallet_offline_create_transaction(self):
     hdkey_wif = 'tprv8ZgxMBicQKsPf5exCdeBgnYjJt2LxDcQbv6u9HHymY3qh6EoTy8SGwou5xyvExL3iWfBsZWp3YUyo9gRmxQxrBS2FwGk' \
                 'qjcDhTcyVLhrXXZ'
     hdkey = HDKey(hdkey_wif)
     wlt = wallet_create_or_open('offline-create-transaction', key=hdkey, network='testnet',
                                 databasefile=DATABASEFILE_UNITTESTS)
     wlt.get_key()
     utxos = [{
         'address': 'n2S9Czehjvdmpwd2YqekxuUC1Tz5ZdK3YN',
         'script': '',
         'confirmations': 10,
         'output_n': 1,
         'tx_hash': '9df91f89a3eb4259ce04af66ad4caf3c9a297feea5e0b3bc506898b6728c5003',
         'value': 8970937
     }]
     wlt.utxos_update(utxos=utxos)
     t = wlt.transaction_create([('n2S9Czehjvdmpwd2YqekxuUC1Tz5ZdK3YN', 100)], fee=5000)
     t.sign()
     self.assertTrue(t.verify())
     del wlt
コード例 #23
0
 def test_wallet_multisig_create_2_cosigner_wallets(self):
     if os.path.isfile(DATABASEFILE_UNITTESTS):
         os.remove(DATABASEFILE_UNITTESTS)
     pk_wif1 = 'tprv8ZgxMBicQKsPdvHCP6VxtFgowj2k7nBJnuRiVWE4DReDFojkLjyqdT8mtR6XJK9dRBcaa3RwvqiKFjsEQVhKfQmHZCCY' \
               'f4jRTWvJuVuK67n'
     pk_wif2 = 'tprv8ZgxMBicQKsPdkJVWDkqQQAMVYB2usfVs3VS2tBEsFAzjC84M3TaLMkHyJWjydnJH835KHvksS92ecuwwWFEdLAAccwZ' \
               'KjhcA63NUyvDixB'
     pk1 = HDKey(pk_wif1, network='testnet')
     pk2 = HDKey(pk_wif2, network='testnet')
     wl1 = HDWallet.create_multisig('multisig_test_wallet1',
                                    [pk_wif1, pk2.subkey_for_path("m/45'/1'/0'").wif_public()],
                                    sigs_required=2, network='testnet', databasefile=DATABASEFILE_UNITTESTS)
     wl2 = HDWallet.create_multisig('multisig_test_wallet2',
                                    [pk1.subkey_for_path("m/45'/1'/0'").wif_public(), pk_wif2],
                                    sigs_required=2, network='testnet', databasefile=DATABASEFILE_UNITTESTS)
     wl1_key = wl1.new_key()
     wl2_key = wl2.new_key()
     self.assertEqual(wl1_key.address, wl2_key.address)
コード例 #24
0
from bitcoinlib.config.config import BCL_DATABASE_DIR
from bitcoinlib.keys import HDKey
from bitcoinlib.wallets import HDWallet

test_databasefile = os.path.join(BCL_DATABASE_DIR, 'bitcoinlib.test.sqlite')
test_database = 'sqlite:///' + test_databasefile
if os.path.isfile(test_databasefile):
    os.remove(test_databasefile)

#
# Create a multi-signature wallet using Bitcoinlib testnet and then create a transaction
#

# Create 3 wallets with one private keys each, and 2 public keys corresponding with other wallets
NETWORK = 'bitcoinlib_test'
pk1 = HDKey(network=NETWORK)
pk2 = HDKey(network=NETWORK)
pk3 = HDKey(network=NETWORK)
klist = [pk1, pk2.public_master_multisig(), pk3.public_master_multisig()]
wl1 = HDWallet.create('multisig_2of3_cosigner1',
                      sigs_required=2,
                      keys=klist,
                      network=NETWORK,
                      db_uri=test_database)
klist = [pk1.public_master_multisig(), pk2, pk3.public_master_multisig()]
wl2 = HDWallet.create('multisig_2of3_cosigner2',
                      sigs_required=2,
                      keys=klist,
                      network=NETWORK,
                      db_uri=test_database)
klist = [pk1.public_master_multisig(), pk2.public_master_multisig(), pk3]
コード例 #25
0
# * P2WPKH - Pay-to-wallet-public-key-hash, Native SegWit single key
# * P2WSH - Pay-to-wallet-script-hash, Native SegWit multisig/script
# * P2SH-P2WPKH - P2WPKH nested in a P2SH script
# * P2SH-P2WSH - P2WSH nested in P2SH script
#
# If you deposit at least 0.001 TBTC test bitcoins to the first wallet, several transactions will be created for every
# kind of segwit wallet
#

from bitcoinlib.wallets import wallet_create_or_open, wallet_create_or_open_multisig
from bitcoinlib.keys import HDKey
from time import sleep

wif = 'tprv8ZgxMBicQKsPdpenF8SX1WMsr6eaS3rZgqhqVu1LJ3wkAp1NhREnFrsvzK4A7ERrHhxqjzZpoESRjwpgrrhjC1cWALzZRxoycCNz8jBNWre'
wif2 = 'tprv8ZgxMBicQKsPdktmSG4hGs6kq3dmTMmiDtLZwaipsCYxqbhtqWH69kNGZvNufnemLTCP3gbypLf1koKfAEujo5cnWPKBg3YbpZa63J9Cqtj'
cowif2 = HDKey(wif2).account_multisig_key()

#
# CREATE WALLETS
#

# Segwit P2SH-P2WPKH Wallet
w1 = wallet_create_or_open('segwit_testnet_p2sh_p2wpkh',
                           key=wif,
                           witness_type='p2sh-segwit',
                           network='testnet')
w1_key = w1.get_key()

# Segwit Native P2WPKH Wallet
w2 = wallet_create_or_open('segwit_testnet_p2wpkh',
                           key=wif,
コード例 #26
0
ファイル: wallets.py プロジェクト: 1200wd/bitcoinlib
    def from_key(name, wallet_id, session, key='', account_id=0, network='bitcoin', change=0, purpose=44, parent_id=0,
                 path='m'):
        k = HDKey(import_key=key, network=network)
        keyexists = session.query(DbKey).filter(DbKey.key_wif == k.extended_wif()).all()
        if keyexists:
            raise WalletError("Key %s already exists" % k.extended_wif())

        if k.depth() != len(path.split('/'))-1:
            if path == 'm' and k.depth() == 3:
                # Create path when importing new account-key
                networkcode = networks.NETWORKS[network]['bip44_cointype']
                path = "m/%d'/%s'/%d'" % (purpose, networkcode, account_id)
            else:
                raise WalletError("Key depth of %d does not match path lenght of %d" %
                                  (k.depth(), len(path.split('/')) - 1))

        wk = session.query(DbKey).filter(or_(DbKey.key == str(k.private()),
                                             DbKey.key_wif == k.extended_wif(),
                                             DbKey.address == k.public().address())).first()
        if wk:
            return HDWalletKey(wk.id, session)

        nk = DbKey(name=name, wallet_id=wallet_id, key=str(k.private()), purpose=purpose,
                   account_id=account_id, depth=k.depth(), change=change, address_index=k.child_index(),
                   key_wif=k.extended_wif(), address=k.public().address(), parent_id=parent_id,
                   is_private=True, path=path, key_type=k.key_type)
        session.add(nk)
        session.commit()
        return HDWalletKey(nk.id, session)
コード例 #27
0
ファイル: mnemonic.py プロジェクト: unoffices/bitcoinlib
print("Hex                %s" % pk)
print("Checksum bin       %s" % Mnemonic().checksum(pk))
print("Mnemonic           %s" % words)
print("Seed for HD Key    %s" %
      to_hexstring(Mnemonic().to_seed(words, 'test')))
print("Back to Entropy    %s" % to_hexstring(Mnemonic().to_entropy(words)))

# Generate a random Mnemonic HD Key
print("\nGenerate a random Mnemonic HD Key")
entsize = 128
words = Mnemonic('english').generate(entsize)
print("Your Mnemonic is   %s" % words)
print("  (An avarage of %d tries is needed to brute-force this password)" %
      ((2**entsize) // 2))
seed = Mnemonic().to_seed(words)
hdk = HDKey().from_seed(seed)
print("Seed for HD Key    %s" % to_hexstring(seed))
print("HD Key WIF is      %s" % hdk.wif())

# Generate a key from a Mnemonic sentence
print("\nGenerate a key from a Mnemonic sentence")
words = "type fossil omit food supply enlist move perfect direct grape clean diamond"
print("Your Mnemonic is   %s" % words)
seed = Mnemonic().to_seed(words)
hdk = HDKey().from_seed(seed)
print("Seed for HD Key    %s" % to_hexstring(seed))
print("HD Key WIF is      %s" % hdk.wif())

# Let's talk Spanish
print("\nGenerate a key from a Spanish Mnemonic sentence")
words = "laguna afirmar talón resto peldaño deuda guerra dorado catorce avance oasis barniz"
コード例 #28
0
                           network='testnet')
w1_key = w1.get_key()

# Segwit Native P2WPKH Wallet
w2 = wallet_create_or_open('segwit_testnet_p2wpkh',
                           keys=wif,
                           witness_type='segwit',
                           network='testnet')
w2_key = w2.get_key()

# Segwit Native P2WSH Wallet
w3 = wallet_create_or_open(
    'segwit_testnet_p2wsh',
    keys=[
        wif,
        HDKey(wif2).public_master_multisig(witness_type='segwit').public()
    ],
    witness_type='segwit',
    network='testnet')
w3_key = w3.get_key()

# Segwit P2SH-P2WSH Wallet
w4 = wallet_create_or_open('segwit_testnet_p2sh_p2wsh',
                           keys=[
                               wif,
                               HDKey(wif2).public_master_multisig(
                                   witness_type='p2sh-segwit').public()
                           ],
                           witness_type='p2sh-segwit',
                           network='testnet')
w4_key = w4.get_key()
コード例 #29
0
ファイル: keys.py プロジェクト: Moliholy/bitcoinlib
k = Key('5KN7MzqK5wt2TP1fQCYyHBtDrXdJuXbUzm4A9rKAteGu3Qi5CVR')
print("Private key     %s" % k.wif())
print("Encrypted pk    %s " % k.bip38_encrypt('TestingOneTwoThree'))
print("Is Compressed   %s\n" % k.compressed)

print("\n=== Import and Decrypt BIP38 Key ===")
k = Key('6PRVWUbkzzsbcVac2qwfssoUJAN1Xhrg6bNk8J7Nzm5H7kxEbn2Nh2ZoGg',
        passphrase='TestingOneTwoThree')
print("Private key     %s" % k.wif())
print("Is Compressed   %s\n" % k.compressed)

#
# Hierarchical Deterministic Key Class and Child Key Derivation Examples
#
print("\n=== Generate random HD Key on testnet ===")
hdk = HDKey(network='testnet')
print("Random BIP32 HD Key on testnet %s" % hdk.wif())

print("\n=== Import HD Key from seed ===")
k = HDKey.from_seed('000102030405060708090a0b0c0d0e0f')
print("HD Key WIF for seed 000102030405060708090a0b0c0d0e0f:  %s" % k.wif())
print("Key type is : %s" % k.key_type)

print("\n=== Generate random Litecoin key ===")
lk = HDKey(network='litecoin')
lk.info()

print("\n=== Generate random Dash key ===")
lk = HDKey(network='dash')
lk.info()
コード例 #30
0
        'tpubD6NzVbkrYhZ4XfKVKY9LUfXh4t3ZHMDw9Q2SUUDTCCXrzFGfLm6v5n4frZWNfc5fwkbc33C3FwvbwbxgrDGKNSL2WcLAhPcZXijrQvLvyYA'
    },
]

if not wallet_exists(WALLET_NAME):
    # This wallets key list, use tools/mnemonic_key_create.py to create your own.
    #

    cosigners_private = []
    key_list = []
    for cosigner in cosigners:
        if not cosigner['key']:
            raise ValueError(
                "Please create private keys with mnemonic_key_create.py and add to COSIGNERS definitions"
            )
        hdkey = HDKey(cosigner['key'], key_type=cosigner['key_type'])
        if hdkey.is_private:
            cosigners_private.append(cosigner['name'])
        cosigner['hdkey'] = hdkey
        key_list.append(hdkey)

    # YOU SHOULD ENABLE THIS CHECK FOR REAL WALLETS
    # if len(cosigners_private) > 1:
    #    raise ValueError("It is strongly advised to use not more then 1 private key per wallet.")

    if len(key_list) != SIGS_N:
        raise ValueError(
            "Number of cosigners (%d) is different then expected. SIG_N=%d" %
            (len(key_list), SIGS_N))
    wallet3o5 = HDWallet.create_multisig(WALLET_NAME,
                                         key_list,
コード例 #31
0
ファイル: cli_wallet.py プロジェクト: phamels/bitcoinlib
def main():
    print("Command Line Wallet for BitcoinLib\n")
    # --- Parse commandline arguments ---
    args = parse_args()

    databasefile = DEFAULT_DATABASE
    if args.database:
        databasefile = os.path.join(BCL_DATABASE_DIR, args.database)

    if args.generate_key:
        passphrase = get_passphrase(args)
        passphrase = ' '.join(passphrase)
        seed = binascii.hexlify(Mnemonic().to_seed(passphrase))
        hdkey = HDKey.from_seed(seed, network=args.network)
        print(
            "Private master key, to create multisig wallet on this machine: %s"
            % hdkey.wif())
        print(
            "Public account key, to share with other cosigner multisig wallets: %s"
            %
            hdkey.public_master(witness_type=args.witness_type, multisig=True))
        print("Network: %s" % hdkey.network.name)
        clw_exit()

    # List wallets, then exit
    if args.list_wallets:
        print("BitcoinLib wallets:")
        for w in wallets_list(databasefile=databasefile):
            if 'parent_id' in w and w['parent_id']:
                continue
            print("[%d] %s (%s) %s" %
                  (w['id'], w['name'], w['network'], w['owner']))
        clw_exit()

    # Delete specified wallet, then exit
    if args.wallet_remove:
        if not wallet_exists(args.wallet_name, databasefile=databasefile):
            clw_exit("Wallet '%s' not found" % args.wallet_name)
        inp = input(
            "\nWallet '%s' with all keys and will be removed, without private key it cannot be restored."
            "\nPlease retype exact name of wallet to proceed: " %
            args.wallet_name)
        if inp == args.wallet_name:
            if wallet_delete(args.wallet_name,
                             force=True,
                             databasefile=databasefile):
                clw_exit("\nWallet %s has been removed" % args.wallet_name)
            else:
                clw_exit("\nError when deleting wallet")
        else:
            clw_exit("\nSpecified wallet name incorrect")

    wlt = None
    if args.wallet_name and not args.wallet_name.isdigit(
    ) and not wallet_exists(args.wallet_name, databasefile=databasefile):
        if not args.create_from_key and input(
                "Wallet %s does not exist, create new wallet [yN]? " %
                args.wallet_name).lower() != 'y':
            clw_exit('Aborted')
        wlt = create_wallet(args.wallet_name, args, databasefile)
        args.wallet_info = True
    else:
        try:
            wlt = HDWallet(args.wallet_name, databasefile=databasefile)
            if args.passphrase is not None:
                print(
                    "WARNING: Using passphrase option for existing wallet ignored"
                )
            if args.create_from_key is not None:
                print(
                    "WARNING: Using create_from_key option for existing wallet ignored"
                )
        except WalletError as e:
            clw_exit("Error: %s" % e.msg)

    if wlt is None:
        clw_exit("Could not open wallet %s" % args.wallet_name)

    if args.import_private:
        if wlt.import_key(args.import_private):
            clw_exit("Private key imported")
        else:
            clw_exit("Failed to import key")

    if args.wallet_recreate:
        wallet_empty(args.wallet_name)
        print("Removed transactions and generated keys from this wallet")
    if args.update_utxos:
        wlt.utxos_update()
    if args.update_transactions:
        wlt.scan(scan_gap_limit=5)

    if args.export_private:
        if wlt.scheme == 'multisig':
            for w in wlt.cosigner:
                if w.main_key and w.main_key.is_private:
                    print(w.main_key.wif)
        elif not wlt.main_key or not wlt.main_key.is_private:
            print("No private key available for this wallet")
        else:
            print(wlt.main_key.wif)
        clw_exit()

    if args.network is None:
        args.network = wlt.network.name

    tx_import = None
    if args.import_tx_file:
        try:
            fn = args.import_tx_file
            f = open(fn, "r")
        except FileNotFoundError:
            clw_exit("File %s not found" % args.import_tx_file)
        try:
            tx_import = ast.literal_eval(f.read())
        except (ValueError, SyntaxError):
            tx_import = f.read()
    if args.import_tx:
        try:
            tx_import = ast.literal_eval(args.import_tx)
        except (ValueError, SyntaxError):
            tx_import = args.import_tx
    if tx_import:
        if isinstance(tx_import, dict):
            wt = wlt.transaction_import(tx_import)
        else:
            wt = wlt.transaction_import_raw(tx_import, network=args.network)
        wt.sign()
        if args.push:
            res = wt.send()
            if res:
                print("Transaction pushed to network. Transaction ID: %s" %
                      wt.hash)
            else:
                print("Error creating transaction: %s" % wt.error)
        wt.info()
        print("Signed transaction:")
        print_transaction(wt)
        clw_exit()

    if args.receive:
        keys = wlt.get_key(network=args.network, number_of_keys=args.receive)
        if args.receive != 1:
            keys += wlt.get_key_change(network=args.network,
                                       number_of_keys=args.receive)
        keys = [keys] if not isinstance(keys, list) else keys
        print("Receive address(es):")
        for key in keys:
            addr = key.address
            print(addr)
            if QRCODES_AVAILABLE and args.receive == 1:
                qrcode = pyqrcode.create(addr)
                print(qrcode.terminal())
        if not QRCODES_AVAILABLE and args.receive == 1:
            print(
                "Install qr code module to show QR codes: pip install pyqrcode"
            )
        clw_exit()
    if args.create_transaction == []:
        clw_exit("Missing arguments for --create-transaction/-t option")
    if args.create_transaction:
        if args.fee_per_kb:
            clw_exit("Fee-per-kb option not allowed with --create-transaction")
        try:
            wt = create_transaction(wlt, args.create_transaction, args)
        except WalletError as e:
            clw_exit("Cannot create transaction: %s" % e.msg)
        wt.sign()
        print("Transaction created")
        wt.info()
        if args.push:
            wt.send()
            if wt.pushed:
                print("Transaction pushed to network. Transaction ID: %s" %
                      wt.hash)
            else:
                print("Error creating transaction: %s" % wt.error)
        else:
            print(
                "\nTransaction created but not send yet. Transaction dictionary for export: "
            )
            print_transaction(wt)
        clw_exit()
    if args.sweep:
        if args.fee:
            clw_exit("Fee option not allowed with --sweep")
        offline = True
        print("Sweep wallet. Send all funds to %s" % args.sweep)
        if args.push:
            offline = False
        wt = wlt.sweep(args.sweep,
                       offline=offline,
                       network=args.network,
                       fee_per_kb=args.fee_per_kb)
        if not wt:
            clw_exit(
                "Error occurred when sweeping wallet: %s. Are UTXO's available and updated?"
                % wt)
        wt.info()
        if args.push:
            if wt.pushed:
                print("Transaction pushed to network. Transaction ID: %s" %
                      wt.hash)
            elif not wt:
                print("Cannot sweep wallet, are UTXO's updated and available?")
            else:
                print("Error sweeping wallet: %s" % wt.error)
        else:
            print(
                "\nTransaction created but not send yet. Transaction dictionary for export: "
            )
            print_transaction(wt)
        clw_exit()

    # print("Updating wallet")
    if args.network == 'bitcoinlib_test':
        wlt.utxos_update()
    print("Wallet info for %s" % wlt.name)
    wlt.info()
コード例 #32
0
ファイル: test_wallets.py プロジェクト: ydxt25/bitcoinlib
 def test_wallet_multisig_sorted_keys(self):
     if os.path.isfile(DATABASEFILE_UNITTESTS):
         os.remove(DATABASEFILE_UNITTESTS)
     key1 = HDKey()
     key2 = HDKey()
     key3 = HDKey()
     w1 = HDWallet.create_multisig('w1', [
         key1,
         key2.account_multisig_key().public(),
         key3.account_multisig_key().public()
     ],
                                   sigs_required=2,
                                   sort_keys=True,
                                   databasefile=DATABASEFILE_UNITTESTS)
     w2 = HDWallet.create_multisig('w2', [
         key1.account_multisig_key().public(), key2,
         key3.account_multisig_key().public()
     ],
                                   sigs_required=2,
                                   sort_keys=True,
                                   databasefile=DATABASEFILE_UNITTESTS)
     w3 = HDWallet.create_multisig('w3', [
         key1.account_multisig_key().public(),
         key2.account_multisig_key().public(), key3
     ],
                                   sigs_required=2,
                                   sort_keys=True,
                                   databasefile=DATABASEFILE_UNITTESTS)
     for _ in range(10):
         address1 = w1.new_key().address
         address2 = w2.new_key().address
         address3 = w3.new_key().address
         self.assertTrue((address1 == address2 == address3),
                         'Different addressed generated: %s %s %s' %
                         (address1, address2, address3))