def test_should_work(self):
privkey = KeyPair.PrivateKeyFromWIF(
"L44B5gGEpqEDRS9vVPz7QT35jcBG2r3CZwSwQ4fCewXAhAhqGVpP")
self.assertEqual(
binascii.hexlify(privkey),
b"cbf4b9f70470856bb4f40f80b87edb90865997ffee6df315ab166d713af433a5"
)
def execute(self, arguments):
wallet = PromptData.Wallet
if len(arguments) != 1:
print("Please specify the required parameter")
return False
wif = arguments[0]
try:
kp = KeyPair.PrivateKeyFromWIF(wif)
except ValueError as e:
print(f"WIF Error: {str(e)}")
return False
try:
key = wallet.CreateKey(kp)
print(f"Imported key: {wif}")
pub_key = key.PublicKey.encode_point(True).decode('utf-8')
print(f"Pubkey: {pub_key}")
print(f"Address: {key.GetAddress()}")
except Exception as e:
# couldn't find an exact call that throws this but it was in the old code. Leaving it in for now.
print(f"Key creation error: {str(e)}")
return False
return True
def test_publickey_to_scripthash(self):
expected_scripthash = binascii.unhexlify(
'79ecf967a02f9bdbd147fc97b18efd7877d27f78')
priv_key = KeyPair.PrivateKeyFromWIF(
'L44B5gGEpqEDRS9vVPz7QT35jcBG2r3CZwSwQ4fCewXAhAhqGVpP')
kp = KeyPair(priv_key=priv_key)
pub_bytes = kp.PublicKey.encode_point(True)
result = Helper.pubkey_to_pubhash(pub_bytes)
self.assertEqual(result, expected_scripthash)
def test_6_import_wif(self):
wallet = self.GetWallet1()
key_to_import = 'L3MBUkKU5kYg16KSZnqcaTj2pG5ei3fN9A4X7rxXys18GBDa3bH8'
prikey = KeyPair.PrivateKeyFromWIF(key_to_import)
keypair = wallet.CreateKey(prikey)
key_out = keypair.PublicKey.encode_point(True).decode('utf-8')
self.assertEqual(key_out, '03f3a3b5a4d873933fc7f4b53113e8eb999fb20038271fbbb10255585670c3c312')
def example2():
source_address = "AJQ6FoaSXDFzA6wLnyZ1nFN7SGSN2oNTc3"
source_script_hash = address_to_scripthash(source_address)
# start by creating a base InvocationTransaction
# the inputs, outputs and Type do not have to be set anymore.
invocation_tx = InvocationTransaction()
# Since we are building a raw transaction, we will add the raw_tx flag
invocation_tx.raw_tx = True
# often times smart contract developers use the function ``CheckWitness`` to determine if the transaction is signed by somebody eligible of calling a certain method
# in order to pass that check you want to add the corresponding script_hash as a transaction attribute (this is generally the script_hash of the public key you use for signing)
# Note that for public functions like the NEP-5 'getBalance' and alike this would not be needed, but it doesn't hurt either
invocation_tx.Attributes.append(
TransactionAttribute(usage=TransactionAttributeUsage.Script,
data=source_script_hash))
# next we need to build a 'script' that gets executed against the smart contract.
# this is basically the script that calls the entry point of the contract with the necessary parameters
smartcontract_scripthash = UInt160.ParseString(
"31730cc9a1844891a3bafd1aa929a4142860d8d3")
sb = ScriptBuilder()
# call the NEP-5 `name` method on the contract (assumes contract address is a NEP-5 token)
sb.EmitAppCallWithOperation(smartcontract_scripthash, 'name')
invocation_tx.Script = binascii.unhexlify(sb.ToArray())
# at this point we've build our unsigned transaction and it's time to sign it before we get the raw output that we can send to the network via RPC
# we need to create a Wallet instance for helping us with signing
wallet = UserWallet.Create('path',
to_aes_key('mypassword'),
generate_default_key=False)
# if you have a WIF use the following
# this WIF comes from the `neo-test1-w.wallet` fixture wallet
private_key = KeyPair.PrivateKeyFromWIF(
"Ky94Rq8rb1z8UzTthYmy1ApbZa9xsKTvQCiuGUZJZbaDJZdkvLRV")
# if you have a NEP2 encrypted key use the following instead
# private_key = KeyPair.PrivateKeyFromNEP2("NEP2 key string", "password string")
# we add the key to our wallet
wallet.CreateKey(private_key)
# and now we're ready to sign
context = ContractParametersContext(invocation_tx)
wallet.Sign(context)
invocation_tx.scripts = context.GetScripts()
raw_tx = invocation_tx.ToArray()
return raw_tx
def test_should_throw_error_on_invalid_checksum(self):
# build fake wif
fakewif = bytearray(34 * 'A', 'utf8')
fakewif[0] = 0x80
fakewif[33] = 0x01
# fake checksum
fakewif.append(0xDE)
fakewif.append(0xAD)
fakewif.append(0xBE)
fakewif.append(0xEF)
encodedFakeWIF = base58.b58encode(bytes(fakewif))
with self.assertRaises(ValueError) as context:
KeyPair.PrivateKeyFromWIF(encodedFakeWIF)
self.assertEqual('Invalid WIF Checksum!', str(context.exception))
def test_c(self):
key = KeyPair(priv_key=self.decrypted_pk)
self.assertEqual(key.PublicKey.x, self.pubkey_x)
self.assertEqual(key.PublicKey.y, self.pubkey_y)
self.assertEqual(key.PublicKey.encode_point(True), self.pubkey_encoded)
self.assertEqual(key.PublicKey.encode_point(False),
self.pubkey_not_comp)
self.assertIsInstance(key.PublicKeyHash, UInt160)
self.assertEqual(key.PublicKeyHash.ToBytes(), self.pubkeyhash)
self.assertEqual(key.Export(), self.wif)
private_key_from_wif = KeyPair.PrivateKeyFromWIF(self.wif)
self.assertEqual(private_key_from_wif, self.pk)
def test_publickey_to_redeemscript_to_scripthash_to_address(self):
# NEP 2 testvector
expected_redeemscript = binascii.unhexlify(
'21026241e7e26b38bb7154b8ad49458b97fb1c4797443dc921c5ca5774f511a2bbfcac'
)
expected_scripthash = binascii.unhexlify(
'79ecf967a02f9bdbd147fc97b18efd7877d27f78')
expected_address = 'AStZHy8E6StCqYQbzMqi4poH7YNDHQKxvt'
priv_key = KeyPair.PrivateKeyFromWIF(
'L44B5gGEpqEDRS9vVPz7QT35jcBG2r3CZwSwQ4fCewXAhAhqGVpP')
kp = KeyPair(priv_key=priv_key)
pub_bytes = kp.PublicKey.encode_point(True)
redeemscript = Helper.pubkey_to_redeem(pub_bytes)
scripthash = Helper.redeem_to_scripthash(redeemscript)
address = Helper.scripthash_to_address(scripthash)
self.assertEqual(redeemscript, expected_redeemscript)
self.assertEqual(scripthash, expected_scripthash)
self.assertEqual(address, expected_address)
def test_sign_and_verify_str(self):
privkey = KeyPair.PrivateKeyFromWIF(
"L44B5gGEpqEDRS9vVPz7QT35jcBG2r3CZwSwQ4fCewXAhAhqGVpP")
keypair = KeyPair(privkey)
hashdata = "74657374"
keypair_signature = Crypto.Sign(hashdata, bytes(keypair.PrivateKey))
keypair_signature2 = Crypto.Default().Sign(hashdata,
bytes(keypair.PrivateKey))
self.assertEqual(keypair_signature, keypair_signature2)
# verify without unhexing
verification_result = Crypto.VerifySignature("test",
keypair_signature,
keypair.PublicKey,
unhex=False)
verification_result2 = Crypto.Default().VerifySignature(
"test", keypair_signature, keypair.PublicKey, unhex=False)
self.assertEqual(verification_result, verification_result2)
self.assertTrue(verification_result)
def test_sign_and_verify(self):
privkey = KeyPair.PrivateKeyFromWIF(
"L44B5gGEpqEDRS9vVPz7QT35jcBG2r3CZwSwQ4fCewXAhAhqGVpP")
keypair = KeyPair(privkey)
hashdata = b'aabbcc'
keypair_signature = Crypto.Sign(hashdata, bytes(keypair.PrivateKey))
keypair_signature2 = Crypto.Default().Sign(hashdata,
bytes(keypair.PrivateKey))
self.assertEqual(keypair_signature, keypair_signature2)
verification_result = Crypto.VerifySignature(hashdata.decode('utf8'),
keypair_signature,
keypair.PublicKey)
verification_result2 = Crypto.Default().VerifySignature(
hashdata.decode('utf8'), keypair_signature, keypair.PublicKey)
self.assertEqual(verification_result, verification_result2)
self.assertTrue(verification_result)
# verify with compressed key
verification_result3 = Crypto.VerifySignature(
hashdata.decode('utf8'), keypair_signature,
binascii.unhexlify(keypair.PublicKey.encode_point(True)))
self.assertTrue(verification_result3)
# verify without unhexxing
verification_result4 = Crypto.VerifySignature(
binascii.unhexlify(hashdata),
keypair_signature,
binascii.unhexlify(keypair.PublicKey.encode_point(True)),
unhex=False)
self.assertTrue(verification_result4)
# this should fail because the signature will not match the input data
verification_result = Crypto.VerifySignature(b'aabb',
keypair_signature,
keypair.PublicKey)
self.assertFalse(verification_result)
def main():
parser = argparse.ArgumentParser(
description=
'A utility for signing messages. Example usage: "np-sign mymessage --wallet_file path/to/my/wallet" or use an NEP2 key/passphrase like "np-sign mymessage -n"'
)
parser.add_argument('message',
type=str,
help='The message in string format to be signed')
parser.add_argument(
'-w',
'--wallet_file',
type=str,
default=None,
help='If using a wallet file, the path to the wallet file')
parser.add_argument(
'-a',
'--address',
type=str,
default=False,
help=
'If using a wallet file with more than 1 address, the address you would like to use. Otherwise the default address will be used'
)
parser.add_argument(
'-n',
'--nep2',
action='store_true',
help="Whether to use an NEP2 passhrase rather than a wallet")
parser.add_argument('--wif',
type=str,
default=None,
help='If using a wif pass in the wif')
args = parser.parse_args()
try:
if args.wallet_file:
passwd = prompt('[Wallet password]> ', is_password=True)
wallet = UserWallet.Open(args.wallet_file, to_aes_key(passwd))
contract = wallet.GetDefaultContract()
if args.address:
addr = args.address
script_hash = Helper.AddrStrToScriptHash(addr)
contract = wallet.GetContract(script_hash)
if contract is None:
raise Exception('Address %s not found in wallet %s ' %
(addr, args.wallet_file))
print("Signing With Address %s " % contract.Address)
signature, pubkey = wallet.SignMessage(args.message,
contract.ScriptHash)
pubkey = pubkey.encode_point().decode('utf-8')
signature = signature.hex()
print("pubkey, sig: %s %s " % (pubkey, signature))
elif args.nep2:
nep2_key = prompt('[nep2 key]> ', is_password=True)
nep2_passwd = prompt("[nep2 key password]> ", is_password=True)
prikey = KeyPair.PrivateKeyFromNEP2(nep2_key, nep2_passwd)
keypair = KeyPair(priv_key=prikey)
contract = Contract.CreateSignatureContract(keypair.PublicKey)
print("Signing With Address %s " % contract.Address)
signature = Crypto.Sign(args.message, prikey)
pubkey = keypair.PublicKey.encode_point().decode('utf-8')
signature = signature.hex()
print("pubkey, sig: %s %s " % (pubkey, signature))
elif args.wif:
prikey = KeyPair.PrivateKeyFromWIF(args.wif)
keypair = KeyPair(priv_key=prikey)
contract = Contract.CreateSignatureContract(keypair.PublicKey)
print("Signing With Address %s " % contract.Address)
signature = Crypto.Sign(args.message, prikey)
pubkey = keypair.PublicKey.encode_point().decode('utf-8')
signature = signature.hex()
print("pubkey, sig: %s %s " % (pubkey, signature))
except Exception as e:
print("Could not sign: %s " % e)
def test_should_throw_error_on_invalid_wif(self):
with self.assertRaises(ValueError) as context:
KeyPair.PrivateKeyFromWIF(52 * 'A')
self.assertEqual('Invalid format!', str(context.exception))
def test_should_throw_error_on_too_short_wif(self):
with self.assertRaises(ValueError) as context:
KeyPair.PrivateKeyFromWIF('brokenwif')
self.assertIn('Please provide a wif with a length of 52 bytes',
str(context.exception))
def example1():
neo_asset_id = Blockchain.GetSystemShare().Hash
gas_asset_id = Blockchain.GetSystemCoin().Hash
source_address = "AJQ6FoaSXDFzA6wLnyZ1nFN7SGSN2oNTc3"
source_script_hash = address_to_scripthash(source_address)
destination_address = "Ad9A1xPbuA5YBFr1XPznDwBwQzdckAjCev"
destination_script_hash = address_to_scripthash(destination_address)
# Let's start with building a ContractTransaction
# The constructor already sets the correct `Type` and `Version` fields, so we do not have to worry about that
contract_tx = ContractTransaction()
# Since we are building a raw transaction, we will add the raw_tx flag
contract_tx.raw_tx = True
# Next we can add Attributes if we want. Again the various types are described in point 4. of the main link above
# We will add a simple "description"
contract_tx.Attributes.append(
TransactionAttribute(usage=TransactionAttributeUsage.Description,
data="My raw contract transaction description"))
# The next field we will set are the inputs. The inputs neo-python expects are of the type ``CoinReference``
# To create these inputs we will need the usual `PrevHash` and `PrevIndex` values.
# You can get the required data by using e.g. the neoscan.io API: https://api.neoscan.io/docs/index.html#api-v1-get-3
# The `PrevHash` field equals to neoscan's `balance.unspent[index].txid` key, and `PrevIndex` comes from `balance.unspent[index].n`
# It is up to the transaction creator to make sure that the sum of all input ``value`` fields is equal to or bigger than the amount that's intended to be send
# The below values are taken from data out of the `neo-test1-w.wallet` fixture wallet (a wallet neo-python uses for internal testing)
input1 = CoinReference(prev_hash=UInt256(data=binascii.unhexlify(
'949354ea0a8b57dfee1e257a1aedd1e0eea2e5837de145e8da9c0f101bfccc8e')),
prev_index=1)
contract_tx.inputs = [input1]
# Next we will create the outputs.
# The above input has a value of 50. We will create 2 outputs.
# 1 output for sending 3 NEO to a specific destination address
send_to_destination_output = TransactionOutput(
AssetId=neo_asset_id,
Value=Fixed8.FromDecimal(3),
script_hash=destination_script_hash)
# and a second output for sending the change back to ourselves
return_change_output = TransactionOutput(AssetId=neo_asset_id,
Value=Fixed8.FromDecimal(47),
script_hash=source_script_hash)
contract_tx.outputs = [send_to_destination_output, return_change_output]
# at this point we've build our unsigned transaction and it's time to sign it before we get the raw output that we can send to the network via RPC
# we need to create a Wallet instance for helping us with signing
wallet = UserWallet.Create('path',
to_aes_key('mypassword'),
generate_default_key=False)
# if you have a WIF use the following
# this WIF comes from the `neo-test1-w.wallet` fixture wallet
private_key = KeyPair.PrivateKeyFromWIF(
"Ky94Rq8rb1z8UzTthYmy1ApbZa9xsKTvQCiuGUZJZbaDJZdkvLRV")
# if you have a NEP2 encrypted key use the following instead
# private_key = KeyPair.PrivateKeyFromNEP2("NEP2 key string", "password string")
# we add the key to our wallet
wallet.CreateKey(private_key)
# and now we're ready to sign
context = ContractParametersContext(contract_tx)
wallet.Sign(context)
contract_tx.scripts = context.GetScripts()
print(contract_tx.Hash.ToString())
raw_tx = contract_tx.ToArray()
return raw_tx
