repo_id stringclasses 409
values | prefix large_stringlengths 34 36.3k | target large_stringlengths 1 498 | assertion_type stringclasses 31
values | difficulty stringclasses 8
values | test_file stringlengths 10 121 | test_function stringlengths 1 104 | test_class stringlengths 0 51 | lineno int32 2 11.3k | commit_idx int32 |
|---|---|---|---|---|---|---|---|---|---|
richardkiss/pycoin | import threading
import unittest
from pycoin.encoding.hexbytes import h2b_rev
from pycoin.services import providers
from pycoin.services.blockchain_info import BlockchainInfoProvider
from pycoin.services.blockcypher import BlockcypherProvider
from pycoin.services.blockexplorer import BlockExplorerProvider
from pycoin.... | len(CS.split())) | self.assertEqual | func_call | tests/services/services_test.py | test_env | ServicesTest | 33 | null |
richardkiss/pycoin | import unittest
import pycoin
class VersionTest(unittest.TestCase):
def test_version_not_empty(self):
"""Test that __version__ is not empty."""
self.assertNotEqual(pycoin.__version__, | "") | self.assertNotEqual | string_literal | tests/version_test.py | test_version_not_empty | VersionTest | 17 | null |
richardkiss/pycoin | import unittest
from pycoin.encoding.hexbytes import h2b, h2b_rev, b2h, b2h_rev
class HexbytesTest(unittest.TestCase):
def test_h2b(self):
h = "000102"
b = b"\x00\x01\x02"
self.assertEqual(h2b(h), b)
self.assertEqual(b2h(b), | h) | self.assertEqual | variable | tests/hexbytes.py | test_h2b | HexbytesTest | 12 | null |
richardkiss/pycoin | import unittest
from pycoin.symbols.btc import network
who_signed_tx = network.who_signed.who_signed_tx
Tx = network.tx
SIGHASH_ALL = network.validator.flags.SIGHASH_ALL
class WhoSignedTest(unittest.TestCase):
def multisig_M_of_N(self, M, N, unsigned_id, signed_id):
keys = [network.keys.private(secret_e... | 0) | self.assertEqual | numeric_literal | tests/who_signed_test.py | multisig_M_of_N | WhoSignedTest | 26 | null |
richardkiss/pycoin | import unittest
from pycoin.blockchain.ChainFinder import ChainFinder
def do_scramble(items, tfb, dbt):
import itertools
for c in itertools.permutations(items):
cf = ChainFinder()
load_items(cf, c)
assert cf.trees_from_bottom == tfb
assert cf.descendents_by_top == dbt
c... | {-1: {1}} | assert | collection | tests/chainfinder_test.py | test_basics | ChainFinderTestCase | 54 | null |
richardkiss/pycoin | import unittest
import pycoin
class VersionTest(unittest.TestCase):
def test_version_is_string(self):
"""Test that __version__ is a string."""
self.assertIsInstance(pycoin.__version__, | str) | self.assertIsInstance | variable | tests/version_test.py | test_version_is_string | VersionTest | 13 | null |
richardkiss/pycoin | import pytest
import unittest
from pycoin.encoding.bytes32 import to_bytes_32
from pycoin.encoding.hexbytes import h2b
from pycoin.symbols.grs import network as GroestlcoinMainnet
pytest.importorskip('groestlcoin_hash')
class GroestlcoinEncodingTestCase(unittest.TestCase):
def do_test(sec_bytes, wif, addres... | wif) | self.assertEqual | variable | tests/grs/grs_encoding_test.py | do_test | GroestlcoinEncodingTestCase | 34 | null |
richardkiss/pycoin | import unittest
from pycoin.encoding.b58 import a2b_hashed_base58, b2a_hashed_base58
from pycoin.networks.registry import network_for_netcode
from pycoin.networks.registry import network_codes
from pycoin.symbols.btc import network as BTC
from pycoin.symbols.xtn import network as XTN
NETCODES = "BTC XTN DOGE".split()... | network.parse.wif(a)) | self.assertIsNone | func_call | tests/key_validate_test.py | test_is_wif_valid | KeyUtilsTest | 66 | null |
richardkiss/pycoin | import unittest
import pycoin
class VersionTest(unittest.TestCase):
def test_version_is_defined(self):
"""Test that __version__ attribute is defined."""
self.assertTrue(hasattr(pycoin, '__version__'))
self.assertIsNotNone( | pycoin.__version__) | self.assertIsNotNone | complex_expr | tests/version_test.py | test_version_is_defined | VersionTest | 9 | null |
richardkiss/pycoin | import unittest
from ctypes import byref, c_size_t, create_string_buffer
from pycoin.ecdsa.secp256k1 import secp256k1_generator
from pycoin.ecdsa.native.secp256k1 import libsecp256k1, SECP256K1_EC_UNCOMPRESSED
from pycoin.encoding.bytes32 import from_bytes_32, to_bytes_32
from pycoin.encoding.hexbytes import b2h
from... | 1) | self.assertEqual | numeric_literal | tests/ecdsa/libsecp256k1_test.py | test_sign_verify_mutual_compatibility | ECDSATestCase | 44 | null |
richardkiss/pycoin | import io
import unittest
from pycoin.encoding.hexbytes import h2b
from pycoin.message.make_parser_and_packer import (
make_parser_and_packer, standard_messages, standard_message_post_unpacks,
standard_parsing_functions, standard_streamer
)
from pycoin.message.PeerAddress import ip_bin_to_ip4_addr, ip_bin_to_i... | ii_prime) | self.assertEqual | variable | tests/message_test.py | test_InvItem | MessageTest | 81 | null |
richardkiss/pycoin | import unittest
from pycoin.encoding.hexbytes import h2b
from pycoin.symbols.btc import network as BTC
from pycoin.symbols.xtn import network as XTN
class Bip0032TestCase(unittest.TestCase):
def test_vector_2(self):
master = BTC.keys.bip32_seed(h2b(
"fffcf9f6f3f0edeae7e4e1dedbd8d5d2cfccc9c6c3... | m0.hwif()) | self.assertEqual | func_call | tests/btc/bip32_test.py | test_vector_2 | Bip0032TestCase | 125 | null |
richardkiss/pycoin | import pytest
import unittest
from pycoin.encoding.bytes32 import to_bytes_32
from pycoin.encoding.hexbytes import h2b
from pycoin.symbols.grs import network as GroestlcoinMainnet
pytest.importorskip('groestlcoin_hash')
class GroestlcoinEncodingTestCase(unittest.TestCase):
def test_bip32(self):
xprv = (... | b'\xd8\x80\xd7\xd8') | self.assertEqual | string_literal | tests/grs/grs_encoding_test.py | test_bip32 | GroestlcoinEncodingTestCase | 51 | null |
richardkiss/pycoin | import unittest
from pycoin.symbols.btc import network
who_signed_tx = network.who_signed.who_signed_tx
Tx = network.tx
SIGHASH_ALL = network.validator.flags.SIGHASH_ALL
class WhoSignedTest(unittest.TestCase):
def multisig_M_of_N(self, M, N, unsigned_id, signed_id):
keys = [network.keys.private(secret_e... | ids[i-1]) | self.assertEqual | complex_expr | tests/who_signed_test.py | test_multisig_one_at_a_time | WhoSignedTest | 55 | null |
richardkiss/pycoin | import binascii
import struct
import unittest
ML = [
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
7, 4, 13, 1, 10, 6, 15, 3, 12, 0, 9, 5, 2, 14, 11, 8,
3, 10, 14, 4, 9, 15, 8, 1, 2, 7, 0, 6, 13, 11, 5, 12,
1, 9, 11, 10, 0, 8, 12, 4, 13, 3, 7, 15, 14, 5, 6, 2,
4, 0, 5, 9, 7, 12, 2, 10, 14, ... | hexout) | self.assertEqual | variable | pycoin/contrib/ripemd160.py | test_ripemd160 | TestFrameworkKey | 142 | null |
richardkiss/pycoin | import unittest
from pycoin.encoding.hexbytes import h2b
from pycoin.symbols.btc import network
class KeyTest(unittest.TestCase):
def test_sign_verify(self):
private_key = network.keys.private(secret_exponent=1)
h = b"\x16" * 32
sig = private_key.sign(h)
self.assertTrue(private_ke... | public_key.verify(h, sig)) | self.assertTrue | func_call | tests/key_test.py | test_sign_verify | KeyTest | 15 | null |
richardkiss/pycoin | import io
import unittest
from pycoin.encoding.hexbytes import h2b
from pycoin.message.make_parser_and_packer import (
make_parser_and_packer, standard_messages, standard_message_post_unpacks,
standard_parsing_functions, standard_streamer
)
from pycoin.message.PeerAddress import ip_bin_to_ip4_addr, ip_bin_to_i... | ii0 <= ii1) | self.assertTrue | complex_expr | tests/message_test.py | test_InvItem | MessageTest | 72 | null |
richardkiss/pycoin | import unittest
from pycoin.encoding.hexbytes import h2b
from pycoin.symbols.btc import network as BTC
from pycoin.symbols.xtn import network as XTN
class Bip0032TestCase(unittest.TestCase):
def test_vector_1(self):
master = BTC.keys.bip32_seed(h2b("000102030405060708090a0b0c0d0e0f"))
self.assert... | m0p1.hwif()) | self.assertEqual | func_call | tests/btc/bip32_test.py | test_vector_1 | Bip0032TestCase | 48 | null |
richardkiss/pycoin | import unittest
from pycoin.blockchain.ChainFinder import ChainFinder
def do_scramble(items, tfb, dbt):
import itertools
for c in itertools.permutations(items):
cf = ChainFinder()
load_items(cf, c)
assert cf.trees_from_bottom == tfb
assert cf.descendents_by_top == dbt
c... | {301: {304}} | assert | collection | tests/chainfinder_test.py | test_branch | ChainFinderTestCase | 96 | null |
richardkiss/pycoin | import unittest
from pycoin.encoding.hexbytes import h2b, h2b_rev, b2h, b2h_rev
class HexbytesTest(unittest.TestCase):
def test_h2b(self):
h = "000102"
b = b"\x00\x01\x02"
self.assertEqual(h2b(h), | b) | self.assertEqual | variable | tests/hexbytes.py | test_h2b | HexbytesTest | 11 | null |
richardkiss/pycoin | import unittest
from pycoin.encoding.b58 import a2b_hashed_base58, b2a_hashed_base58
from pycoin.networks.registry import network_for_netcode
from pycoin.networks.registry import network_codes
from pycoin.symbols.btc import network as BTC
from pycoin.symbols.xtn import network as XTN
NETCODES = "BTC XTN DOGE".split()... | "3") | self.assertEqual | string_literal | tests/key_validate_test.py | test_address_valid_btc | KeyUtilsTest | 40 | null |
richardkiss/pycoin | import unittest
from pycoin.encoding.b58 import a2b_hashed_base58, b2a_hashed_base58
from pycoin.networks.registry import network_for_netcode
from pycoin.networks.registry import network_codes
from pycoin.symbols.btc import network as BTC
from pycoin.symbols.xtn import network as XTN
NETCODES = "BTC XTN DOGE".split()... | BTC.parse.address(a)) | self.assertIsNone | func_call | tests/key_validate_test.py | test_address_valid_btc | KeyUtilsTest | 33 | null |
richardkiss/pycoin | import unittest
from pycoin.blockchain.BlockChain import BlockChain
def longest_block_chain(self):
c = []
for idx in range(self.length()):
c.append(self.hash_for_index(idx))
return c
def longest_locked_block_chain(self):
c = []
for idx in range(self.locked_length(), self.length()):
... | 5 | assert | numeric_literal | tests/blockchain_test.py | test_basic | BlockchainTestCase | 54 | null |
richardkiss/pycoin | import unittest
from pycoin.blockchain.ChainFinder import ChainFinder
def do_scramble(items, tfb, dbt):
import itertools
for c in itertools.permutations(items):
cf = ChainFinder()
load_items(cf, c)
assert cf.trees_from_bottom == tfb
assert cf.descendents_by_top == dbt
c... | {-1: {2, 3}} | assert | collection | tests/chainfinder_test.py | test_0123 | ChainFinderTestCase | 120 | null |
richardkiss/pycoin | import unittest
from pycoin.key.subpaths import subpaths_for_path_range
from pycoin.symbols.btc import network
class KeychainTest(unittest.TestCase):
def test_keychain(self):
keychain = network.keychain()
bip32_list = [network.keys.bip32_seed(_) for _ in [b"foo", b"bar"]]
for bip32 in bip... | None) | self.assertEqual | none_literal | tests/keychain_test.py | test_keychain | KeychainTest | 21 | null |
richardkiss/pycoin | import binascii
import unittest
from pycoin.satoshi import stackops
def b2h(b):
return binascii.hexlify(b).decode("utf8")
class StackOpsTest(unittest.TestCase):
def test_do_OP_CAT(self):
s = ["foo", "bar"]
stackops.do_OP_CAT(s)
self.assertEqual(s, | ['foobar']) | self.assertEqual | collection | tests/script/stackops_test.py | test_do_OP_CAT | StackOpsTest | 89 | null |
richardkiss/pycoin | import pytest
import unittest
from pycoin.encoding.bytes32 import to_bytes_32
from pycoin.encoding.hexbytes import h2b
from pycoin.symbols.grs import network as GroestlcoinMainnet
pytest.importorskip('groestlcoin_hash')
class GroestlcoinEncodingTestCase(unittest.TestCase):
def do_test(h160, address):
... | address) | self.assertEqual | variable | tests/grs/grs_encoding_test.py | do_test | GroestlcoinEncodingTestCase | 15 | null |
richardkiss/pycoin | import unittest
from pycoin.cmds.tx import DEFAULT_VERSION
from pycoin.encoding.hexbytes import h2b
from pycoin.symbols.btc import network
Spendable = network.tx.Spendable
Tx = network.tx
TxIn = network.tx.TxIn
TxOut = network.tx.TxOut
class SignTest(unittest.TestCase):
def multisig_M_of_N(self, M, N, unsigned_... | ids[i]) | self.assertEqual | complex_expr | tests/sign_test.py | test_multisig_one_at_a_time | SignTest | 70 | null |
richardkiss/pycoin | import unittest
from pycoin.symbols.btc import network
class ParseTest(unittest.TestCase):
def test_parse_script(self):
k = network.parse.script("foo")
self.assertEqual(k, None)
k = network.parse.script("OP_CHECKSIG")
self.assertEqual(k.disassemble(), | "OP_CHECKSIG") | self.assertEqual | string_literal | tests/parse_test.py | test_parse_script | ParseTest | 82 | null |
richardkiss/pycoin | import unittest
from pycoin.contrib.bech32m import bech32_decode, bech32_encode, decode, encode, Encoding
from pycoin.encoding.hexbytes import b2h
class Bech32Test(unittest.TestCase):
def test_bip350_vectors(self):
# from
# https://github.com/bitcoin/bips/blob/master/bip-0350.mediawiki
# #... | encoded) | self.assertEqual | variable | tests/bech32_test.py | test_bip350_vectors | Bech32Test | 25 | null |
richardkiss/pycoin | import unittest
from pycoin.ecdsa.secp256k1 import secp256k1_generator
from pycoin.ecdsa.intstream import to_bytes, from_bytes
class ECDSATestCase(unittest.TestCase):
def do_test(secret_exponent, val_list):
public_point = secret_exponent * secp256k1_generator
for v in val_list:
... | True | assert | bool_literal | tests/ecdsa/ecdsa_test.py | do_test | ECDSATestCase | 82 | null |
richardkiss/pycoin | import hashlib
import struct
import unittest
from pycoin.coins.exceptions import BadSpendableError
from pycoin.symbols.btc import network
Spendable = network.tx.Spendable
BITCOIN_ADDRESSES = [network.keys.private(i).address() for i in range(1, 21)]
WIFS = [network.keys.private(i).wif() for i in range(1, 21)]
FAKE_... | FEE) | self.assertEqual | variable | tests/tx_utils_test.py | test_simple_spend | SpendTest | 44 | null |
richardkiss/pycoin | import threading
import unittest
from pycoin.encoding.hexbytes import h2b_rev
from pycoin.services import providers
from pycoin.services.blockchain_info import BlockchainInfoProvider
from pycoin.services.blockcypher import BlockcypherProvider
from pycoin.services.blockexplorer import BlockExplorerProvider
from pycoin.... | 1 | assert | numeric_literal | tests/services/services_test.py | test_InsightProvider | ServicesTest | 89 | null |
richardkiss/pycoin | import unittest
from pycoin.contrib.bech32m import bech32_decode, bech32_encode, decode, encode, Encoding
from pycoin.encoding.hexbytes import b2h
class Bech32Test(unittest.TestCase):
def test_bip350_vectors(self):
# from
# https://github.com/bitcoin/bips/blob/master/bip-0350.mediawiki
# #... | spec) | self.assertIsNone | variable | tests/bech32_test.py | test_bip350_vectors | Bech32Test | 47 | null |
richardkiss/pycoin | import itertools
import unittest
from pycoin.symbols.btc import network
Tx = network.tx
class MultisigIndividualTest(unittest.TestCase):
def multisig_M_of_N_individually(self, M, N):
keys = [network.keys.private(secret_exponent=i) for i in range(1, N+2)]
tx_in = Tx.TxIn.coinbase_tx_in(script=b'')... | 0) | self.assertEqual | numeric_literal | tests/multisig_individual_test.py | multisig_M_of_N_individually | MultisigIndividualTest | 23 | null |
richardkiss/pycoin | import binascii
import unittest
from pycoin.satoshi import stackops
def b2h(b):
return binascii.hexlify(b).decode("utf8")
class StackOpsTest(unittest.TestCase):
def test_do_OP_IFDUP(self):
s = [1, 2]
stackops.do_OP_IFDUP(s)
self.assertEqual(s, | [1, 2, 2]) | self.assertEqual | collection | tests/script/stackops_test.py | test_do_OP_IFDUP | StackOpsTest | 46 | null |
richardkiss/pycoin | import itertools
import unittest
from pycoin.symbols.btc import network
Tx = network.tx
class MultisigIndividualTest(unittest.TestCase):
def multisig_M_of_N_individually(self, M, N):
keys = [network.keys.private(secret_exponent=i) for i in range(1, N+2)]
tx_in = Tx.TxIn.coinbase_tx_in(script=b'')... | 1) | self.assertEqual | numeric_literal | tests/multisig_individual_test.py | multisig_M_of_N_individually | MultisigIndividualTest | 20 | null |
richardkiss/pycoin | import unittest
from pycoin.symbols.btc import network
who_signed_tx = network.who_signed.who_signed_tx
Tx = network.tx
SIGHASH_ALL = network.validator.flags.SIGHASH_ALL
class WhoSignedTest(unittest.TestCase):
def multisig_M_of_N(self, M, N, unsigned_id, signed_id):
keys = [network.keys.private(secret_e... | 1) | self.assertEqual | numeric_literal | tests/who_signed_test.py | multisig_M_of_N | WhoSignedTest | 22 | null |
richardkiss/pycoin | import unittest
from pycoin.coins.bitcoin.SolutionChecker import TxContext
from pycoin.coins.bitcoin.VM import BitcoinVM
from pycoin.encoding.hexbytes import h2b
from pycoin.intbytes import int2byte
from pycoin.satoshi.opcodes import OPCODE_LIST
from pycoin.satoshi.IntStreamer import IntStreamer
from pycoin.symbols.bt... | as_bytes | assert | variable | tests/tools_test.py | test_bytes | ToolsTest | 28 | null |
richardkiss/pycoin | import binascii
import unittest
from pycoin.encoding.hexbytes import b2h, h2b_rev
from pycoin.symbols.btc import network
Tx = network.tx
TX_E1A18B843FC420734DEEB68FF6DF041A2585E1A0D7DBF3B82AAB98291A6D9952_HEX = (
"0100000001a8f57056b016d7d243fc0fc2a73f9146e7e4c7766ec6033b5ac4cb89c64e"
"19d0000000008a47304402... | "e1a18b843fc420734deeb68ff6df041a2585e1a0d7dbf3b82aab98291a6d9952") | self.assertEqual | string_literal | tests/tx_test.py | test_tx_api | TxTest | 28 | null |
richardkiss/pycoin | import unittest
from pycoin.encoding.hexbytes import h2b
from pycoin.symbols.btc import network
class KeyTest(unittest.TestCase):
def test_sign_verify(self):
private_key = network.keys.private(secret_exponent=1)
h = b"\x16" * 32
sig = private_key.sign(h)
self.assertTrue( | private_key.verify(h, sig)) | self.assertTrue | func_call | tests/key_test.py | test_sign_verify | KeyTest | 13 | null |
richardkiss/pycoin | import io
import unittest
from pycoin.encoding.hexbytes import h2b
from pycoin.symbols.btc import network
Block = network.block
Tx = network.tx
flags = network.validator.flags
block_80971_cs = h2b('00000000001126456C67A1F5F0FF0268F53B4F22E0531DC70C7B69746AF69DAC')
block_80971_data = h2b(
"01000000950A1631FB9FAC4... | tx2) | self.assertEqual | variable | tests/build_tx_test.py | test_coinbase_tx | BuildTxTest | 107 | null |
richardkiss/pycoin | import pytest
import unittest
from pycoin.encoding.bytes32 import to_bytes_32
from pycoin.encoding.hexbytes import h2b
from pycoin.symbols.grs import network as GroestlcoinMainnet
pytest.importorskip('groestlcoin_hash')
class GroestlcoinEncodingTestCase(unittest.TestCase):
def test_bip32(self):
xprv = (... | xprv) | self.assertEqual | variable | tests/grs/grs_encoding_test.py | test_bip32 | GroestlcoinEncodingTestCase | 57 | null |
richardkiss/pycoin | import binascii
import unittest
from pycoin.encoding.hexbytes import b2h, h2b_rev
from pycoin.symbols.btc import network
Tx = network.tx
TX_E1A18B843FC420734DEEB68FF6DF041A2585E1A0D7DBF3B82AAB98291A6D9952_HEX = (
"0100000001a8f57056b016d7d243fc0fc2a73f9146e7e4c7766ec6033b5ac4cb89c64e"
"19d0000000008a47304402... | "19LemzJ3XPdUxp113uynqCAivDbXZBdBy3") | self.assertEqual | string_literal | tests/tx_test.py | test_tx_api | TxTest | 30 | null |
richardkiss/pycoin | import unittest
from pycoin.encoding.hexbytes import h2b
from pycoin.encoding.sec import (
is_sec_compressed, public_pair_to_sec, sec_to_public_pair, public_pair_to_hash160_sec
)
from pycoin.symbols.btc import network
def secret_exponent_to_wif(se, compressed):
return network.keys.private(se, compressed).wif(... | c_wif) | self.assertEqual | variable | tests/btc/key_translation_test.py | do_test | KeyTranslationTest | 35 | null |
richardkiss/pycoin | import unittest
from pycoin.blockchain.ChainFinder import ChainFinder
def do_scramble(items, tfb, dbt):
import itertools
for c in itertools.permutations(items):
cf = ChainFinder()
load_items(cf, c)
assert cf.trees_from_bottom == tfb
assert cf.descendents_by_top == dbt
c... | {301: {302}} | assert | collection | tests/chainfinder_test.py | test_branch | ChainFinderTestCase | 88 | null |
richardkiss/pycoin | import unittest
from ctypes import byref, c_size_t, create_string_buffer
from pycoin.ecdsa.secp256k1 import secp256k1_generator
from pycoin.ecdsa.native.secp256k1 import libsecp256k1, SECP256K1_EC_UNCOMPRESSED
from pycoin.encoding.bytes32 import from_bytes_32, to_bytes_32
from pycoin.encoding.hexbytes import b2h
from... | 0) | self.assertEqual | numeric_literal | tests/ecdsa/libsecp256k1_test.py | test_sign_verify_mutual_compatibility | ECDSATestCase | 59 | null |
richardkiss/pycoin | import unittest
from pycoin.encoding.hexbytes import h2b
from pycoin.symbols.btc import network as BTC
from pycoin.symbols.xtn import network as XTN
class Bip0032TestCase(unittest.TestCase):
def test_vector_2(self):
master = BTC.keys.bip32_seed(h2b(
"fffcf9f6f3f0edeae7e4e1dedbd8d5d2cfccc9c6c3... | m0_2147483647p_1.hwif()) | self.assertEqual | func_call | tests/btc/bip32_test.py | test_vector_2 | Bip0032TestCase | 149 | null |
richardkiss/pycoin | import unittest
from pycoin.contrib.bech32m import bech32_decode, bech32_encode, decode, encode, Encoding
from pycoin.encoding.hexbytes import b2h
class Bech32Test(unittest.TestCase):
def test_bip350_vectors(self):
# from
# https://github.com/bitcoin/bips/blob/master/bip-0350.mediawiki
# #... | hrp) | self.assertIsNone | variable | tests/bech32_test.py | test_bip350_vectors | Bech32Test | 45 | null |
richardkiss/pycoin | import io
import unittest
from pycoin.encoding.hexbytes import h2b
from pycoin.symbols.btc import network
Tx = network.tx
class PayToTest(unittest.TestCase):
def test_recognize_multisig(self):
h = (
"010000000139c92b102879eb95f14e7344e4dd7d481e1238b1bfb1fa0f735068d2927b"
"2314000... | "10c61e258e0a2b19b245a96a2d0a1538fe81cd4ecd547e0a3df7ed6fd3761ada") | self.assertEqual | string_literal | tests/pay_to_test.py | test_recognize_multisig | PayToTest | 31 | null |
richardkiss/pycoin | import unittest
from pycoin.encoding.b58 import a2b_base58, b2a_base58, a2b_hashed_base58, b2a_hashed_base58, is_hashed_base58_valid
from pycoin.encoding.base_conversion import from_long, to_long, EncodingError
from pycoin.encoding.bytes32 import to_bytes_32
from pycoin.encoding.hash import double_sha256, hash160
from... | key.wif()) | self.assertEqual | func_call | tests/encoding_test.py | do_test | EncodingTestCase | 86 | null |
richardkiss/pycoin | import unittest
from pycoin.symbols.btc import network as BTC
from pycoin.symbols.xtn import network as XTN
class KeyParserTest(unittest.TestCase):
def test_parse_bip32_prv(self):
key = BTC.parse("xprv9s21ZrQH143K31AgNK5pyVvW23gHnkBq2wh5aEk6g1s496M8ZMjx"
"ncCKZKgb5jZoY5eSJMJ2Vbyvi... | "19Vqc8uLTfUonmxUEZac7fz1M5c5ZZbAii") | self.assertEqual | string_literal | tests/keyparser_test.py | test_parse_bip32_prv | KeyParserTest | 14 | null |
richardkiss/pycoin | import unittest
from pycoin.blockchain.BlockChain import BlockChain
def longest_block_chain(self):
c = []
for idx in range(self.length()):
c.append(self.hash_for_index(idx))
return c
def longest_locked_block_chain(self):
c = []
for idx in range(self.locked_length(), self.length()):
... | [] | assert | collection | tests/blockchain_test.py | test_fork | BlockchainTestCase | 142 | null |
richardkiss/pycoin | import io
import unittest
from pycoin.encoding.hexbytes import h2b
from pycoin.message.make_parser_and_packer import (
make_parser_and_packer, standard_messages, standard_message_post_unpacks,
standard_parsing_functions, standard_streamer
)
from pycoin.message.PeerAddress import ip_bin_to_ip4_addr, ip_bin_to_i... | pa2) | self.assertNotEqual | variable | tests/message_test.py | test_PeerAddress | MessageTest | 60 | null |
richardkiss/pycoin | import unittest
from pycoin.encoding.hexbytes import h2b
from pycoin.encoding.sec import (
is_sec_compressed, public_pair_to_sec, sec_to_public_pair, public_pair_to_hash160_sec
)
from pycoin.symbols.btc import network
def secret_exponent_to_wif(se, compressed):
return network.keys.private(se, compressed).wif(... | c_sec) | self.assertEqual | variable | tests/btc/key_translation_test.py | do_test | KeyTranslationTest | 61 | null |
richardkiss/pycoin | import unittest
from pycoin.blockchain.BlockChain import BlockChain
def longest_block_chain(self):
c = []
for idx in range(self.length()):
c.append(self.hash_for_index(idx))
return c
def longest_locked_block_chain(self):
c = []
for idx in range(self.locked_length(), self.length()):
... | expected | assert | variable | tests/blockchain_test.py | test_fork | BlockchainTestCase | 158 | null |
richardkiss/pycoin | import unittest
from pycoin.networks.registry import network_for_netcode
class AddressForScriptTest(unittest.TestCase):
def test_issue_225(self):
script = script_for_nulldata(b"foobar")
tx_out = Tx.TxOut(1, script)
address = address_for_script(tx_out.puzzle_script())
... | "(nulldata 666f6f626172)") | self.assertEqual | string_literal | tests/address_for_script_test.py | test_issue_225 | AddressForScriptTest | 74 | null |
richardkiss/pycoin | import unittest
from pycoin.symbols.btc import network as BTC
from pycoin.symbols.xtn import network as XTN
class KeyParserTest(unittest.TestCase):
def test_parse_bip32_prv_xtn(self):
key = XTN.parse("tprv8ZgxMBicQKsPdpQD2swL99YVLB6W2GDqNVcCSfAZ9zMXvh6DYj5iJMZmUVrF66"
"x7uXBDJSune... | "n2ThiotfoCrcRofQcFbCrVX2PC89s2KUjh") | self.assertEqual | string_literal | tests/keyparser_test.py | test_parse_bip32_prv_xtn | KeyParserTest | 25 | null |
richardkiss/pycoin | import binascii
import unittest
from pycoin.encoding.hexbytes import h2b
from pycoin.symbols.btc import network
class ValidationTest(unittest.TestCase):
def setUp(self):
self._key = network.keys.private(1)
def test_validate_multisig_tx(self):
# this is a transaction in the block chain
... | 0) | self.assertEqual | numeric_literal | tests/validation_test.py | test_validate_multisig_tx | ValidationTest | 32 | null |
richardkiss/pycoin | import unittest
import json
import os
from pycoin.encoding.hexbytes import h2b_rev
from pycoin.symbols.btc import network
flags = network.validator.flags
ValidationFailureError = network.validator.ValidationFailureError
DEBUG_TX_ID_LIST = []
TX_VALID_JSON = os.path.dirname(__file__) + '/data/tx_valid.json'
TX_INVAL... | (3, 4) | assert | collection | tests/btc/bc_transaction_test.py | txs_from_json | 46 | null | |
richardkiss/pycoin | import unittest
from pycoin.networks.registry import network_for_netcode
class AddressForScriptTest(unittest.TestCase):
def test_script_type_pay_to_address(self):
for se in range(1, 100):
key = network.keys.private(secret_exponent=se)
for b in [True, False]:
... | addr) | self.assertEqual | variable | tests/address_for_script_test.py | test_script_type_pay_to_address | AddressForScriptTest | 25 | null |
richardkiss/pycoin | import textwrap
import unittest
from pycoin.symbols.btc import network as BTC
from pycoin.symbols.xtn import network as XTN
def test_msg_parse():
"""
Test against real-world signatures found in the wild.
"""
# Output from brainwallet in "multibit" mode.
multibit = '''
-----BEGIN BITCOIN SIGN... | 'This is an example of a signed message.' | assert | string_literal | tests/msg_signing_test.py | test_msg_parse | 66 | null | |
richardkiss/pycoin | import unittest
from pycoin.symbols.btc import network as BTC
from pycoin.symbols.xtn import network as XTN
class KeyParserTest(unittest.TestCase):
def test_parse_wif(self):
key = BTC.parse("KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3qYjgd9M7rFU73sVHnoWn")
self.assertEqual(key.secret_exponent(), | 1) | self.assertEqual | numeric_literal | tests/keyparser_test.py | test_parse_wif | KeyParserTest | 81 | null |
richardkiss/pycoin | import unittest
from pycoin.networks.registry import network_for_netcode
class DisassembleTest(unittest.TestCase):
def test_disassemble(self):
input_tx = Tx.from_hex(
"01000000010000000000000000000000000000000000000000000000000000000000000000"
"ffffffff0704ffff... | "f4184fc596403b9d638783cf57adfe4c75c605f6356fbc91338530e9831e9e16") | self.assertEqual | string_literal | tests/annotate_test.py | test_disassemble | DisassembleTest | 53 | null |
richardkiss/pycoin | import unittest
from pycoin.cmds.tx import DEFAULT_VERSION
from pycoin.encoding.hexbytes import h2b
from pycoin.symbols.btc import network
Spendable = network.tx.Spendable
Tx = network.tx
TxIn = network.tx.TxIn
TxOut = network.tx.TxOut
class SignTest(unittest.TestCase):
def multisig_M_of_N(self, M, N, unsigned_... | "9618820d7037d2f32db798c92665231cd4599326f5bd99cb59d0b723be2a13a2") | self.assertEqual | string_literal | tests/sign_test.py | test_sign_bitcoind_partially_signed_2_of_2 | SignTest | 135 | null |
richardkiss/pycoin | import unittest
from pycoin.blockchain.ChainFinder import ChainFinder
def do_scramble(items, tfb, dbt):
import itertools
for c in itertools.permutations(items):
cf = ChainFinder()
load_items(cf, c)
assert cf.trees_from_bottom == tfb
assert cf.descendents_by_top == | dbt | assert | variable | tests/chainfinder_test.py | do_scramble | 28 | null | |
richardkiss/pycoin | import unittest
from pycoin.key.subpaths import subpaths_for_path_range
from pycoin.symbols.btc import network
class KeychainTest(unittest.TestCase):
def test_keychain(self):
keychain = network.keychain()
bip32_list = [network.keys.bip32_seed(_) for _ in [b"foo", b"bar"]]
for bip32 in bip... | subkey.secret_exponent()) | self.assertEqual | func_call | tests/keychain_test.py | test_keychain | KeychainTest | 19 | null |
richardkiss/pycoin | import threading
import unittest
from pycoin.encoding.hexbytes import h2b_rev
from pycoin.services import providers
from pycoin.services.blockchain_info import BlockchainInfoProvider
from pycoin.services.blockcypher import BlockcypherProvider
from pycoin.services.blockexplorer import BlockExplorerProvider
from pycoin.... | []) | self.assertEqual | collection | tests/services/services_test.py | subthread | ServicesTest | 45 | null |
richardkiss/pycoin | import unittest
from pycoin.coins.bitcoin.SolutionChecker import TxContext
from pycoin.coins.bitcoin.VM import BitcoinVM
from pycoin.encoding.hexbytes import h2b
from pycoin.intbytes import int2byte
from pycoin.satoshi.opcodes import OPCODE_LIST
from pycoin.satoshi.IntStreamer import IntStreamer
from pycoin.symbols.bt... | 1 | assert | numeric_literal | tests/tools_test.py | test_bytes | ToolsTest | 27 | null |
richardkiss/pycoin | import io
import unittest
from pycoin.encoding.hexbytes import h2b
from pycoin.message.make_parser_and_packer import (
make_parser_and_packer, standard_messages, standard_message_post_unpacks,
standard_parsing_functions, standard_streamer
)
from pycoin.message.PeerAddress import ip_bin_to_ip4_addr, ip_bin_to_i... | ii1 >= ii0) | self.assertTrue | complex_expr | tests/message_test.py | test_InvItem | MessageTest | 73 | null |
richardkiss/pycoin | import threading
import unittest
from pycoin.encoding.hexbytes import h2b_rev
from pycoin.services import providers
from pycoin.services.blockchain_info import BlockchainInfoProvider
from pycoin.services.blockcypher import BlockcypherProvider
from pycoin.services.blockexplorer import BlockExplorerProvider
from pycoin.... | tx_id) | self.assertEqual | variable | tests/services/services_test.py | check_provider_tx_for_tx_hash | ServicesTest | 60 | null |
richardkiss/pycoin | import textwrap
import unittest
from pycoin.symbols.btc import network as BTC
from pycoin.symbols.xtn import network as XTN
def test_against_myself():
"""
Test code that verifies against ourselves only. Useful but not so great.
"""
for wif, right_addr in [
('L4gXBvYrXHo59HLeyem94D... | sig | assert | variable | tests/msg_signing_test.py | test_against_myself | 28 | null | |
richardkiss/pycoin | import unittest
from pycoin.ecdsa.secp256k1 import secp256k1_generator
from pycoin.ecdsa.intstream import to_bytes, from_bytes
class ECDSATestCase(unittest.TestCase):
def do_test(secret_exponent, val_list):
public_point = secret_exponent * secp256k1_generator
for v in val_list:
... | False | assert | bool_literal | tests/ecdsa/ecdsa_test.py | do_test | ECDSATestCase | 88 | null |
richardkiss/pycoin | import unittest
from pycoin.ecdsa.secp256k1 import secp256k1_generator
from pycoin.ecdsa.intstream import to_bytes, from_bytes
class ECDSATestCase(unittest.TestCase):
def test_verify_simple(self):
public_pair = secp256k1_generator * 1
self.assertEqual(public_pair, (
550662630222773436... | True) | self.assertEqual | bool_literal | tests/ecdsa/ecdsa_test.py | test_verify_simple | ECDSATestCase | 74 | null |
richardkiss/pycoin | import unittest
from pycoin.symbols.btc import network as BTC
from pycoin.symbols.xtn import network as XTN
class KeyParserTest(unittest.TestCase):
def test_parse_bip32_prv_xtn(self):
key = XTN.parse("tprv8ZgxMBicQKsPdpQD2swL99YVLB6W2GDqNVcCSfAZ9zMXvh6DYj5iJMZmUVrF66"
"x7uXBDJSune... | "mp1nuBzKGgv4ZtS5x8YywbCLD5CnVfT7hV") | self.assertEqual | string_literal | tests/keyparser_test.py | test_parse_bip32_prv_xtn | KeyParserTest | 24 | null |
richardkiss/pycoin | import unittest
from pycoin.ecdsa.secp256k1 import secp256k1_generator
class SigningTest(unittest.TestCase):
def test_sign(self):
PART1 = ["47f7616ea6f9b923076625b4488115de1ef1187f760e65f89eb6f4f7ff04b012"]
PART2 = [x * 64 for x in "123456789abcde"]
VAL = 28832970699858290
for se i... | v) | self.assertTrue | variable | tests/ecdsa/signature_test.py | test_sign | SigningTest | 18 | null |
richardkiss/pycoin | import unittest
from pycoin.encoding.hexbytes import h2b
from pycoin.symbols.btc import network
class KeyTest(unittest.TestCase):
def do_test(exp_hex, wif, c_wif, public_pair_sec, c_public_pair_sec, address_b58, c_address_b58):
secret_exponent = int(exp_hex, 16)
sec = h2b(public_pair_... | c_sec) | self.assertEqual | variable | tests/key_test.py | do_test | KeyTest | 46 | null |
richardkiss/pycoin | import unittest
from pycoin.symbols.btc import network as BTC
from pycoin.symbols.xtn import network as XTN
class KeyParserTest(unittest.TestCase):
def test_parse_bip32_prv_xtn(self):
key = XTN.parse("tprv8ZgxMBicQKsPdpQD2swL99YVLB6W2GDqNVcCSfAZ9zMXvh6DYj5iJMZmUVrF66"
"x7uXBDJSune... | "n31129TfTCBky6N9RyitnGTf3t4LYwCV6A") | self.assertEqual | string_literal | tests/keyparser_test.py | test_parse_bip32_prv_xtn | KeyParserTest | 27 | null |
richardkiss/pycoin | import unittest
from pycoin.ecdsa.secp256r1 import secp256r1_generator
VECTORS = """
k = 1
x = 6B17D1F2E12C4247F8BCE6E563A440F277037D812DEB33A0F4A13945D898C296
y = 4FE342E2FE1A7F9B8EE7EB4A7C0F9E162BCE33576B315ECECBB6406837BF51F5
k = 2
x = 7CF27B188D034F7E8A52380304B51AC3C08969E277F21B35A60B48FC47669978
y = 07775510D... | k2) | self.assertEqual | variable | tests/ecdsa/secp256r1_test.py | test_multiply | Secp256r1Test | 223 | null |
richardkiss/pycoin | import unittest
from pycoin.contrib.bech32m import bech32_decode, bech32_encode, decode, encode, Encoding
from pycoin.encoding.hexbytes import b2h
class Bech32Test(unittest.TestCase):
def test_bip350_vectors(self):
# from
# https://github.com/bitcoin/bips/blob/master/bip-0350.mediawiki
# #... | (None, None)) | self.assertEqual | collection | tests/bech32_test.py | test_bip350_vectors | Bech32Test | 93 | null |
richardkiss/pycoin | import unittest
from pycoin.encoding.hexbytes import h2b, h2b_rev, b2h, b2h_rev
class HexbytesTest(unittest.TestCase):
def test_h2b(self):
h = "000102"
b = b"\x00\x01\x02"
self.assertEqual(h2b(h), b)
self.assertEqual(b2h(b), h)
self.assertEqual(h2b_rev(h), | b[::-1]) | self.assertEqual | complex_expr | tests/hexbytes.py | test_h2b | HexbytesTest | 13 | null |
richardkiss/pycoin | import unittest
from pycoin.blockchain.ChainFinder import ChainFinder
def do_scramble(items, tfb, dbt):
import itertools
for c in itertools.permutations(items):
cf = ChainFinder()
load_items(cf, c)
assert cf.trees_from_bottom == tfb
assert cf.descendents_by_top == dbt
c... | {} | assert | collection | tests/chainfinder_test.py | test_basics | ChainFinderTestCase | 44 | null |
richardkiss/pycoin | import unittest
from pycoin.coins.bitcoin.SolutionChecker import TxContext
from pycoin.coins.bitcoin.VM import BitcoinVM
from pycoin.encoding.hexbytes import h2b
from pycoin.intbytes import int2byte
from pycoin.satoshi.opcodes import OPCODE_LIST
from pycoin.satoshi.IntStreamer import IntStreamer
from pycoin.symbols.bt... | b2) | self.assertEqual | variable | tests/tools_test.py | check | ToolsTest | 56 | null |
richardkiss/pycoin | import unittest
from pycoin.encoding.b58 import a2b_base58, b2a_base58, a2b_hashed_base58, b2a_hashed_base58, is_hashed_base58_valid
from pycoin.encoding.base_conversion import from_long, to_long, EncodingError
from pycoin.encoding.bytes32 import to_bytes_32
from pycoin.encoding.hash import double_sha256, hash160
from... | as_sec) | self.assertEqual | variable | tests/encoding_test.py | do_test | EncodingTestCase | 116 | null |
richardkiss/pycoin | import pytest
import unittest
from pycoin.encoding.bytes32 import to_bytes_32
from pycoin.encoding.hexbytes import h2b
from pycoin.symbols.grs import network as GroestlcoinMainnet
pytest.importorskip('groestlcoin_hash')
class GroestlcoinEncodingTestCase(unittest.TestCase):
def test_bip32(self):
xprv = (... | xpub) | self.assertEqual | variable | tests/grs/grs_encoding_test.py | test_bip32 | GroestlcoinEncodingTestCase | 58 | null |
richardkiss/pycoin | import unittest
from pycoin.cmds.tx import DEFAULT_VERSION
from pycoin.encoding.hexbytes import h2b
from pycoin.symbols.btc import network
Spendable = network.tx.Spendable
Tx = network.tx
TxIn = network.tx.TxIn
TxOut = network.tx.TxOut
class SignTest(unittest.TestCase):
def multisig_M_of_N(self, M, N, unsigned_... | ids[i-1]) | self.assertEqual | complex_expr | tests/sign_test.py | test_multisig_one_at_a_time | SignTest | 67 | null |
richardkiss/pycoin | import binascii
import unittest
from pycoin.satoshi import stackops
def b2h(b):
return binascii.hexlify(b).decode("utf8")
class StackOpsTest(unittest.TestCase):
def test_do_OP_2DROP(self):
s = [1, 2, 3]
stackops.do_OP_2DROP(s)
self.assertEqual(s, | [1]) | self.assertEqual | collection | tests/script/stackops_test.py | test_do_OP_2DROP | StackOpsTest | 16 | null |
richardkiss/pycoin | import unittest
from pycoin.encoding.bytes32 import to_bytes_32
from pycoin.encoding.hash import double_sha256
from pycoin.encoding.hexbytes import b2h, b2h_rev, h2b
from pycoin.symbols.btc import network
Tx = network.tx
TxOut = network.tx.TxOut
SIGHASH_ALL = network.validator.flags.SIGHASH_ALL
SIGHASH_SINGLE = netw... | tx_u.id()) | self.assertEqual | func_call | tests/btc/segwit_test.py | check_bip143_tx | SegwitTest | 108 | null |
richardkiss/pycoin | import unittest
from pycoin.symbols.btc import network
who_signed_tx = network.who_signed.who_signed_tx
Tx = network.tx
SIGHASH_ALL = network.validator.flags.SIGHASH_ALL
class WhoSignedTest(unittest.TestCase):
def multisig_M_of_N(self, M, N, unsigned_id, signed_id):
keys = [network.keys.private(secret_e... | t2) | self.assertEqual | variable | tests/who_signed_test.py | test_multisig_one_at_a_time | WhoSignedTest | 61 | null |
richardkiss/pycoin | import unittest
from pycoin.blockchain.BlockChain import BlockChain
def longest_block_chain(self):
c = []
for idx in range(self.length()):
c.append(self.hash_for_index(idx))
return c
def longest_locked_block_chain(self):
c = []
for idx in range(self.locked_length(), self.length()):
... | 0 | assert | numeric_literal | tests/blockchain_test.py | test_basic | BlockchainTestCase | 43 | null |
richardkiss/pycoin | import unittest
from pycoin.blockchain.BlockChain import BlockChain
def longest_block_chain(self):
c = []
for idx in range(self.length()):
c.append(self.hash_for_index(idx))
return c
def longest_locked_block_chain(self):
c = []
for idx in range(self.locked_length(), self.length()):
... | i | assert | variable | tests/blockchain_test.py | test_large | BlockchainTestCase | 210 | null |
richardkiss/pycoin | import unittest
from pycoin.encoding.hexbytes import h2b
from pycoin.symbols.btc import network
class KeyTest(unittest.TestCase):
def do_test(exp_hex, wif, c_wif, public_pair_sec, c_public_pair_sec, address_b58, c_address_b58):
secret_exponent = int(exp_hex, 16)
sec = h2b(public_pair_... | wif) | self.assertEqual | variable | tests/key_test.py | do_test | KeyTest | 39 | null |
richardkiss/pycoin | import unittest
from pycoin.ecdsa.secp256k1 import secp256k1_generator
from pycoin.ecdsa.intstream import to_bytes, from_bytes
class ECDSATestCase(unittest.TestCase):
def test_inverse_mod(self):
prime = secp256k1_generator.curve().p()
order = secp256k1_generator.order()
for v in range(70)... | 1 | assert | numeric_literal | tests/ecdsa/ecdsa_test.py | test_inverse_mod | ECDSATestCase | 115 | null |
richardkiss/pycoin | import unittest
from pycoin.encoding.hexbytes import h2b
from pycoin.symbols.btc import network as BTC
from pycoin.symbols.xtn import network as XTN
class Bip0032TestCase(unittest.TestCase):
def test_vector_2(self):
master = BTC.keys.bip32_seed(h2b(
"fffcf9f6f3f0edeae7e4e1dedbd8d5d2cfccc9c6c3... | m0_2147483647p.hwif()) | self.assertEqual | func_call | tests/btc/bip32_test.py | test_vector_2 | Bip0032TestCase | 137 | null |
richardkiss/pycoin | import unittest
from pycoin.networks.registry import network_for_netcode
class AddressForScriptTest(unittest.TestCase):
def test_weird_tx(self):
# this is from tx 12a8d1d62d12307eac6e62f2f14d7e826604e53c320a154593845aa7c8e59fbf
afs_address = address_for_script(b'Q')
s... | None) | self.assertNotEqual | none_literal | tests/address_for_script_test.py | test_weird_tx | AddressForScriptTest | 67 | null |
richardkiss/pycoin | import unittest
from pycoin.blockchain.BlockChain import BlockChain
def longest_block_chain(self):
c = []
for idx in range(self.length()):
c.append(self.hash_for_index(idx))
return c
def longest_locked_block_chain(self):
c = []
for idx in range(self.locked_length(), self.length()):
... | 7 | assert | numeric_literal | tests/blockchain_test.py | test_basic | BlockchainTestCase | 67 | null |
richardkiss/pycoin | import unittest
from pycoin.encoding.hexbytes import h2b
from pycoin.symbols.btc import network
class KeyTest(unittest.TestCase):
def do_test(exp_hex, wif, c_wif, public_pair_sec, c_public_pair_sec, address_b58, c_address_b58):
secret_exponent = int(exp_hex, 16)
sec = h2b(public_pair_... | c_wif) | self.assertEqual | variable | tests/key_test.py | do_test | KeyTest | 40 | null |
richardkiss/pycoin | import unittest
from pycoin.encoding.b58 import a2b_hashed_base58, b2a_hashed_base58
from pycoin.networks.registry import network_for_netcode
from pycoin.networks.registry import network_codes
from pycoin.symbols.btc import network as BTC
from pycoin.symbols.xtn import network as XTN
NETCODES = "BTC XTN DOGE".split()... | text) | self.assertEqual | variable | tests/key_validate_test.py | test_is_public_private_bip32_valid | KeyUtilsTest | 78 | null |
richardkiss/pycoin | import unittest
from pycoin.coins.bitcoin.SolutionChecker import TxContext
from pycoin.coins.bitcoin.VM import BitcoinVM
from pycoin.encoding.hexbytes import h2b
from pycoin.intbytes import int2byte
from pycoin.satoshi.opcodes import OPCODE_LIST
from pycoin.satoshi.IntStreamer import IntStreamer
from pycoin.symbols.bt... | b"\1") | self.assertEqual | string_literal | tests/tools_test.py | test_int_to_from_script_bytes | ToolsTest | 107 | null |
richardkiss/pycoin | import hashlib
import unittest
from pycoin.ecdsa.intstream import from_bytes
from pycoin.ecdsa.rfc6979 import deterministic_generate_k
class RFC6979TestCase(unittest.TestCase):
def test_deterministic_generate_k_A_2_1(self):
"""
The example in https://tools.ietf.org/html/rfc6979#appendix-A.2.3
... | v) | self.assertEqual | variable | tests/ecdsa/rfc6979_test.py | test_deterministic_generate_k_A_2_1 | RFC6979TestCase | 38 | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.