def CreateKey(self, prikey=None):
account = super(UserWallet, self).CreateKey(private_key=prikey)
self._keys[account.PublicKeyHash.ToBytes()] = account
self.OnCreateAccount(account)
contract = WalletContract.CreateSignatureContract(account.PublicKey)
self.AddContract(contract)
return account
def __init__(self, public, is_mainnet):
self._path = 'main123' if is_mainnet else 'test123'
self.AddressVersion = 23
self._lock = RLock()
self._indexedDB = Blockchain.Default()
self.BuildDatabase()
self._keys = {}
self._contracts = self.LoadContracts()
for key, contract in self._contracts.items():
print('contract ScriptHash', contract.ScriptHash)
print('initializing', flush=True)
kp = OnlyPublicKeyPair(public)
self._keys[kp.PublicKeyHash.ToBytes()] = kp
contract = WalletContract.CreateSignatureContract(kp.PublicKey)
if contract.ScriptHash.ToBytes() not in self._contracts.keys():
self._contracts[contract.ScriptHash.ToBytes()] = contract
sh = bytes(contract.ScriptHash.ToArray())
address, created = Address.get_or_create(ScriptHash=sh)
address.IsWatchOnly = False
address.save()
db_contract = Contract.create(RawData=contract.ToArray(),
ScriptHash=contract.ScriptHash.ToBytes(),
PublicKeyHash=contract.PublicKeyHash.ToBytes(),
Address=address,
Account=None
)
self.LoadNamedAddresses()
self._watch_only = self.LoadWatchOnly()
self._tokens = self.LoadNEP5Tokens()
self._coins = self.LoadCoins()
# self.initialize_holds()
self._holds = VINHold.filter(IsComplete=False)
# Handle EventHub events for SmartContract decorators
@events.on(SmartContractEvent.RUNTIME_NOTIFY)
def call_on_event(sc_event):
# Make sure this event is for this specific smart contract
self.on_notify_sc_event(sc_event)
try:
self._current_height = int(self.LoadStoredData('Height'))
except:
print('setting height to 0')
self._current_height = 0
self.SaveStoredData('Height', self._current_height)
def GetAddress(self):
"""
Returns the public NEO address for this KeyPair
Returns:
str: The private key
"""
contract = Contract.CreateSignatureContract(self.PublicKey)
return contract.Address
def CreateKey(self, prikey=None):
if prikey:
private_key = prikey
else:
private_key = bytes(Random.get_random_bytes(32))
account = WalletKeyPair(priv_key=private_key)
self._keys[account.PublicKeyHash.ToBytes()] = account
self.OnCreateAccount(account)
contract = WalletContract.CreateSignatureContract(account.PublicKey)
self.AddContract(contract)
return account
def test_b(self):
key = KeyPair(priv_key=self.pk)
contract = Contract.CreateSignatureContract(key.PublicKey)
self.assertEqual(binascii.unhexlify(contract.Script), self.contract_script)
self.assertEqual(contract.ScriptHash.ToBytes(), self.contract_script_hash)
self.assertEqual(contract.Address, self.contract_address)
self.assertEqual(contract.PublicKeyHash, key.PublicKeyHash)
self.assertEqual(contract.PublicKeyHash.ToBytes(), self.pubkeyhash)
def sign_context(binary_tx, private):
wallet = Wallet(b'', b'0' * 32, True)
wallet.CreateKey(binascii.unhexlify(private))
script_hash = WalletContract.CreateSignatureContract(
list(wallet._keys.values())[0].PublicKey)
wallet._contracts[script_hash.ScriptHash.ToBytes()] = script_hash
tx = ContractTransaction.DeserializeFromBufer(
binascii.unhexlify(binary_tx))
context = ContractParametersContext(tx, isMultiSig=False)
context.ScriptHashes = [script_hash.ScriptHash]
wallet.Sign(context)
return [x.ToJson() for x in context.GetScripts()]
def CreateKey(self, prikey=None):
"""
Create a KeyPair and store it encrypted in the database.
Args:
private_key (iterable_of_ints): (optional) 32 byte private key.
Returns:
KeyPair: a KeyPair instance.
"""
account = super(UserWallet, self).CreateKey(private_key=prikey)
self.OnCreateAccount(account)
contract = WalletContract.CreateSignatureContract(account.PublicKey)
self.AddContract(contract)
return account
def gather_signatures(context, itx, owners):
do_exit = False
print("\n\n*******************\n")
print("Gather Signatures for Transaction:\n%s " %
json.dumps(itx.ToJson(), indent=4))
print("Please use a client to sign the following: %s " % itx.GetHashData())
owner_index = 0
while not context.Completed and not do_exit:
next_script = owners[owner_index]
next_addr = scripthash_to_address(next_script.Data)
try:
print("\n*******************\n")
owner_input = prompt('Public Key and Signature for %s> ' %
next_addr)
items = owner_input.split(' ')
pubkey = ECDSA.decode_secp256r1(items[0]).G
sig = items[1]
contract = Contract.CreateSignatureContract(pubkey)
if contract.Address == next_addr:
context.Add(contract, 0, sig)
print("Adding signature %s " % sig)
owner_index += 1
else:
print("Public Key does not match address %s " % next_addr)
except ValueError:
# expected from ECDSA if public key is invalid
print(f"Invalid public key: {items[0]}")
do_exit = True
except EOFError:
# Control-D pressed: quit
do_exit = True
except KeyboardInterrupt:
# Control-C pressed: do nothing
do_exit = True
except Exception as e:
print("Could not parse input %s " % e)
if context.Completed:
print("Signatures complete")
itx.scripts = context.GetScripts()
return True
else:
print("Could not finish signatures")
return False
def __init__(self, public, is_mainnet):
self._path = 'main123' if is_mainnet else 'test123'
self.AddressVersion = 23
self._lock = RLock()
self._indexedDB = Blockchain.Default()
self.BuildDatabase()
self._keys = {}
self._contracts = self.LoadContracts()
# for public in ['0294cd0a9e77f358f709e69d9375680b1eafe75373645192b5b251260f484577ea']:
kp = OnlyPublicKeyPair(public)
self._keys[kp.PublicKeyHash.ToBytes()] = kp
contract = WalletContract.CreateSignatureContract(kp.PublicKey)
if contract.ScriptHash.ToBytes() not in self._contracts.keys():
self._contracts[contract.ScriptHash.ToBytes()] = contract
sh = bytes(contract.ScriptHash.ToArray())
address, created = Address.get_or_create(ScriptHash=sh)
address.IsWatchOnly = False
address.save()
db_contract = Contract.create(RawData=contract.ToArray(),
ScriptHash=contract.ScriptHash.ToBytes(),
PublicKeyHash=contract.PublicKeyHash.ToBytes(),
Address=address,
Account=None
)
self.LoadNamedAddresses()
self._watch_only = self.LoadWatchOnly()
self._tokens = self.LoadNEP5Tokens()
self._coins = self.LoadCoins()
self.initialize_holds()
try:
self._current_height = int(self.LoadStoredData('Height'))
except:
print('setting height to 0')
self._current_height = 0
self.SaveStoredData('Height', self._current_height)
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 json_rpc_method_handler(self, method, params):
if method == "getaccountstate":
acct = Blockchain.Default().GetAccountState(params[0])
if acct is None:
try:
acct = AccountState(script_hash=Helper.AddrStrToScriptHash(params[0]))
except Exception as e:
raise JsonRpcError(-2146233033, "One of the identified items was in an invalid format.")
return acct.ToJson()
elif method == "getassetstate":
asset_id = UInt256.ParseString(params[0])
asset = Blockchain.Default().GetAssetState(asset_id.ToBytes())
if asset:
return asset.ToJson()
raise JsonRpcError(-100, "Unknown asset")
elif method == "getbestblockhash":
return '0x%s' % Blockchain.Default().CurrentHeaderHash.decode('utf-8')
elif method == "getblock":
# this should work for either str or int
block = Blockchain.Default().GetBlock(params[0])
if not block:
raise JsonRpcError(-100, "Unknown block")
return self.get_block_output(block, params)
elif method == "getblockcount":
return Blockchain.Default().Height + 1
elif method == "getblockhash":
height = params[0]
if height >= 0 and height <= Blockchain.Default().Height:
return '0x%s' % Blockchain.Default().GetBlockHash(height).decode('utf-8')
else:
raise JsonRpcError(-100, "Invalid Height")
elif method == "getblocksysfee":
height = params[0]
if height >= 0 and height <= Blockchain.Default().Height:
return Blockchain.Default().GetSysFeeAmountByHeight(height)
else:
raise JsonRpcError(-100, "Invalid Height")
elif method == "getconnectioncount":
return len(NodeLeader.Instance().Peers)
elif method == "getcontractstate":
script_hash = UInt160.ParseString(params[0])
contract = Blockchain.Default().GetContract(script_hash.ToBytes())
if contract is None:
raise JsonRpcError(-100, "Unknown contract")
return contract.ToJson()
elif method == "getrawmempool":
return list(map(lambda hash: "0x%s" % hash.decode('utf-8'), NodeLeader.Instance().MemPool.keys()))
elif method == "getversion":
return {
"port": self.port,
"nonce": NodeLeader.Instance().NodeId,
"useragent": settings.VERSION_NAME
}
elif method == "getrawtransaction":
tx_id = UInt256.ParseString(params[0])
tx, height = Blockchain.Default().GetTransaction(tx_id)
if not tx:
raise JsonRpcError(-100, "Unknown Transaction")
return self.get_tx_output(tx, height, params)
elif method == "getLastBlog":
if len(params) > 0:
height = params[0]
else:
height = Blockchain.Default().Height + 1
data = self.get_blog_content(height, "")
return data;
elif method == "getLastBlogByTag":
if len(params) > 1:
height = params[1]
tag = params[0]
elif len(params) > 0:
tag = params[0]
height = Blockchain.Default().Height + 1
else:
raise JsonRpcError(-100, "no enough param")
data = self.get_blog_content(height, tag)
return data;
elif method == "getLastBlogBySender":
if len(params) > 1:
height = params[1]
sender = params[0]
elif len(params) > 0:
sender = params[0]
height = Blockchain.Default().Height + 1
else:
raise JsonRpcError(-100, "no enough param")
data = self.get_blog_content(height, "", sender)
return data;
elif method == "getBlogContent":
tx_id = UInt256.ParseString(params[0])
tx, height = Blockchain.Default().GetTransaction(tx_id)
if not tx:
raise JsonRpcError(-100, "Unknown Transaction")
for attr in tx.Attributes:
item = attr.ToJson;
if item['usage'] == 240:
item['content'] = binascii.a2b_hex(item['data']).decode("utf8")
return item;
raise JsonRpcError(-100, "no blog content")
elif method == "getstorage":
script_hash = UInt160.ParseString(params[0])
key = binascii.unhexlify(params[1].encode('utf-8'))
storage_key = StorageKey(script_hash=script_hash, key=key)
storage_item = Blockchain.Default().GetStorageItem(storage_key)
if storage_item:
return storage_item.Value.hex()
return None
elif method == "gettxout":
hash = params[0].encode('utf-8')
index = params[1]
utxo = Blockchain.Default().GetUnspent(hash, index)
if utxo:
return utxo.ToJson(index)
else:
return None
elif method == "gettxout":
hash = params[0].encode('utf-8')
index = params[1]
utxo = Blockchain.Default().GetUnspent(hash, index)
if utxo:
return utxo.ToJson(index)
else:
return None
elif method == "createAddress":
private_key = bytes(Random.get_random_bytes(32))
key = KeyPair(priv_key=private_key)
self.wallet._keys[key.PublicKeyHash.ToBytes()] = key
self.wallet.OnCreateAccount(key)
contract = WalletContract.CreateSignatureContract(key.PublicKey)
self.wallet.AddContract(contract)
if key :
result = {'privateKey': key.Export(),'address':contract.Address}
return result;
else:
return None
elif method == "invoke":
shash = UInt160.ParseString(params[0])
contract_parameters = [ContractParameter.FromJson(p) for p in params[1]]
sb = ScriptBuilder()
sb.EmitAppCallWithJsonArgs(shash, contract_parameters)
return self.get_invoke_result(sb.ToArray())
# elif method == "sendBlog":
# shash = UInt160.ParseString(params[0])
# contract_parameters = [ContractParameter.FromJson(p) for p in params[1]]
# sb = ScriptBuilder()
# sb.EmitAppCallWithJsonArgs(shash, contract_parameters)
# script = sb.ToArray();
# tx = ContractTransaction()
# tx.inputs = []
# tx.outputs = []
# attribute = TransactionAttribute(240, params[2].encode('utf-8'))
# standard_contract = self.wallet.GetStandardAddress()
# data = standard_contract.Data
# tx.Attributes = [TransactionAttribute(usage=TransactionAttributeUsage.Script,
# data=data)]
#
# tx.Attributes.append(attribute)
# tx.Version = 1
# tx.scripts = []
# BC = GetBlockchain()
# contract = BC.GetContract(params[0])
# output = TransactionOutput(AssetId=Blockchain.SystemShare().Hash,
# Value=Fixed8.FromDecimal(float(1)),
# script_hash=contract.Code.ScriptHash(),
# )
# tx.outputs.append(output)
# logger.info("output %s" % output.ToJson(0))
# tx.Script = binascii.unhexlify(script)
# print("percentage %s %s" % (self.wallet.WalletHeight, Blockchain.Default().Height))
# scripthash_from = None
# if not self.wallet.IsSynced:
# raise JsonRpcError.invalidRequest("wallet not synced")
# private_key = None
# if len(params) > 3:
# from_address = params[3]
# if from_address is not None:
# scripthash_from = lookup_addr_str(self.wallet, from_address)
# if len(params) > 4:
# private_key = params[4]
# wallet_tx = SendBlog(self.wallet, tx, from_addr=scripthash_from, privatekey=private_key)
# if wallet_tx != False:
# return wallet_tx.ToJson();
# self.wallet.Rebuild()
# raise JsonRpcError.invalidRequest("Field 'no enough asset")
elif method == 'postblog':
try:
if len(params) > 3:
from_address = params[3]
assetId =Blockchain.SystemShare().Hash
if len(params) > 4:
private_key = params[4]
if assetId is None:
print("Asset id not found")
return False
contract_parameters = [ContractParameter.FromJson(p) for p in params[1]]
sb = ScriptBuilder()
sb.EmitAppCallWithJsonArgs(UInt160.ParseString(params[0]), contract_parameters)
script = sb.ToArray();
scripthash_from = None
if from_address is not None:
scripthash_from = lookup_addr_str(self.wallet, from_address)
# f8amount = Fixed8.TryParse(0, require_positive=True)
# if f8amount is None:
# print("invalid amount format")
# return False
#
# if type(assetId) is UInt256 and f8amount.value % pow(10, 8 - Blockchain.Default().GetAssetState(
# assetId.ToBytes()).Precision) != 0:
# print("incorrect amount precision")
# return False
#
fee = Fixed8.Zero()
#
# output = TransactionOutput(AssetId=assetId, Value=f8amount, script_hash=contract.Code.ScriptHash())
tx = InvocationTransaction()
ttx = self.wallet.MakeTransaction(tx=tx,
change_address=None,
fee=fee,
from_addr=scripthash_from)
if ttx is None:
print("insufficient funds")
return False
standard_contract = self.wallet.GetStandardAddress()
if scripthash_from is not None:
signer_contract = self.wallet.GetContract(scripthash_from)
else:
signer_contract = self.wallet.GetContract(standard_contract)
if not signer_contract.IsMultiSigContract:
data = scripthash_from.Data
print(data)
tx.Attributes = [TransactionAttribute(usage=TransactionAttributeUsage.Script,
data=data),TransactionAttribute(usage=TransactionAttributeUsage.Remark1,
data=from_address.encode('utf-8'))]
# insert any additional user specified tx attributes
tx.Attributes.append(TransactionAttribute(240, params[2].encode('utf-8')))
tx.Script = binascii.unhexlify(script)
context = ContractParametersContext(tx, isMultiSig=signer_contract.IsMultiSigContract)
if private_key is not None:
prikey = KeyPair.PrivateKeyFromWIF(private_key)
kp = KeyPair(prikey)
self.wallet.Sign(context,kp)
attributes = [attr.ToJson() for attr in tx.Attributes]
print("attributes %s" %attributes)
if context.Completed:
tx.scripts = context.GetScripts()
# print("will send tx: %s " % json.dumps(tx.ToJson(),indent=4))
relayed = NodeLeader.Instance().Relay(tx)
if relayed:
self.wallet.SaveTransaction(tx)
print("Relayed Tx: %s " % tx.Hash.ToString())
return tx.ToJson()
else:
print("Could not relay tx %s " % tx.Hash.ToString())
else:
print("Transaction initiated, but the signature is incomplete")
print(json.dumps(context.ToJson(), separators=(',', ':')))
return False
except Exception as e:
print("could not send: %s " % e)
return False
elif method == "invokefunction":
contract_parameters = []
if len(params) > 2:
contract_parameters = [ContractParameter.FromJson(p).ToVM() for p in params[2]]
sb = ScriptBuilder()
sb.EmitAppCallWithOperationAndArgs(UInt160.ParseString(params[0]), params[1], contract_parameters)
return self.get_invoke_result(sb.ToArray())
elif method == "invokescript":
script = params[0].encode('utf-8')
return self.get_invoke_result(script)
elif method == "sendrawtransaction":
tx_script = binascii.unhexlify(params[0].encode('utf-8'))
transaction = Transaction.DeserializeFromBufer(tx_script)
result = NodeLeader.Instance().Relay(transaction)
return result
elif method == "submitblock":
raise NotImplementedError()
elif method == "validateaddress":
return self.validateaddress(params)
elif method == "getpeers":
raise NotImplementedError()
raise JsonRpcError.methodNotFound()
