def getInformation(hash_value, seed=None):
# 获取IOTA api函数接口
if seed is None:
api = Iota(ip, testnet=True)
else:
api = Iota(ip, seed=seed, testnet=True)
# 获取交易捆绑
bundle = api.get_bundles(hash_value)
# 读取交易信息
message = bundle['bundles'][0].tail_transaction.signature_message_fragment
# 将信息转成json数据格式并返回
jsonData = json.loads(message.decode())
return jsonData
def findmessages(TXN_BUNDLE):
api = Iota('http://node.deviceproof.org:14265')
dict_txn = api.find_transactions(bundles = [TXN_BUNDLE.rstrip()])
if len(dict_txn["hashes"]) == 0:
return ""
tail_hash = dict_txn['hashes']
test = str(tail_hash)[19:100]
bundle = api.get_bundles(test)
signature_message_fragment = str(bundle["bundles"][0][0].signature_message_fragment)
ans = TryteString(signature_message_fragment).decode()
return ans
def findmessages(TXN_BUNDLE):
#print("hello bundle is : " + str(TXN_BUNDLE))
api = Iota('http://node.deviceproof.org:14265')
dict_txn = api.find_transactions(bundles=[TXN_BUNDLE.rstrip()])
#print("Transaction = ",dict_txn['hashes'])
tail_hash = dict_txn['hashes']
test = str(tail_hash)[19:100]
#print("Transaction hash = ",test)
bundle = api.get_bundles(test)
signature_message_fragment = str(
bundle["bundles"][0][0].signature_message_fragment)
ans = TryteString(signature_message_fragment).decode()
return ans
def test_wireup(self):
"""
Verify that the command is wired up correctly. (sync)
The API method indeed calls the appropiate command.
"""
with patch('iota.commands.extended.get_bundles.GetBundlesCommand.__call__',
MagicMock(return_value=async_return('You found me!'))
) as mocked_command:
api = Iota(self.adapter)
# Don't need to call with proper args here.
response = api.get_bundles('transactions')
self.assertTrue(mocked_command.called)
self.assertEqual(
response,
'You found me!'
)
def gen_bundle_info_for_transfer(bundle_idx, label, seed, dst_addr, value):
# api
api = Iota('http://localhost:14265', seed)
# find all transactions for address
trxs = api.find_transactions(addresses=[dst_addr])['hashes']
bundle = None
# try to find the right bundle
for trx in trxs:
try:
trx_bundles = api.get_bundles(trx)['bundles']
for trx_bundle in trx_bundles:
try:
if trx_bundle.transactions[
0].value == value and trx_bundle.transactions[
0].address == dst_addr:
bundle = trx_bundle
break
except:
pass
if bundle:
break
except:
pass
# If trx could not be found, raise and stop now
if not bundle:
raise BaseException("Could not find bundle for trx %s (%di)" %
(dst_addr, value))
bundle_info = \
"""
//!
//! Bundle %d
//! %s
//!
static const std::string BUNDLE_%d_HASH = "%s";
""" % (bundle_idx, label, bundle_idx, bundle.hash)
for i in range(0, len(bundle.transactions)):
trx_idx = i + 1
trx = bundle.transactions[i]
bundle_info += \
"""
static const std::string BUNDLE_%d_TRX_%d_HASH = "%s";
static const std::string BUNDLE_%s_TRX_%s_ADDRESS = "%s";
static const std::string BUNDLE_%d_TRX_%d_ADDRESS_WITHOUT_CHECKSUM = "%s";
static const std::string BUNDLE_%d_TRX_%d_TRYTES = "%s";
static const std::string BUNDLE_%d_TRX_%d_SIGNATURE_FRAGMENT = "%s";
static const int64_t BUNDLE_%d_TRX_%d_CURRENT_INDEX = %d;
static const int64_t BUNDLE_%d_TRX_%d_LAST_INDEX = %d;
static const std::string BUNDLE_%d_TRX_%d_NONCE = "%s";
static const std::string BUNDLE_%d_TRX_%d_TAG = "%s";
static const int64_t BUNDLE_%d_TRX_%d_TS = %d;
static const std::string BUNDLE_%d_TRX_%d_TRUNK = "%s";
static const std::string BUNDLE_%d_TRX_%d_BRANCH = "%s";
static const int64_t BUNDLE_%d_TRX_%d_VALUE = %d;
""" % (
bundle_idx, trx_idx, trx.hash,
bundle_idx, trx_idx, trx.address.with_valid_checksum(),
bundle_idx, trx_idx, trx.address,
bundle_idx, trx_idx, trx.as_tryte_string(),
bundle_idx, trx_idx, trx.signature_message_fragment,
bundle_idx, trx_idx, trx.current_index,
bundle_idx, trx_idx, trx.last_index,
bundle_idx, trx_idx, trx.nonce,
bundle_idx, trx_idx, trx.tag,
bundle_idx, trx_idx, trx.timestamp,
bundle_idx, trx_idx, trx.trunk_transaction_hash,
bundle_idx, trx_idx, trx.branch_transaction_hash,
bundle_idx, trx_idx, trx.value
)
return bundle_info
class MyIOTA:
def __init__(self, node, seed):
self.node = node
self.seed = seed
self.api = False
self._update = False
self.transfers = []
self._debug = False
self.wallet = self.get_filename()
self.addr_dict = {}
self.min_weight_magnitude = 14
self.api = Iota(self.node, self.seed)
self.USED = True
self.NOT_USED = False
def Address(self, addr_string):
return Address(addr_string)
def get_addr_dict(self):
return self.addr_dict
def set_addr_dict(self, addr, value, used):
self.addr_dict[addr] = (value, used)
def s_addr(self, addr, n=3):
s_addr = str(addr)
l = len(s_addr)
return s_addr[:n] + '...' + s_addr[l - n:]
def get_filename(self):
h = hashlib.sha256()
h.update(self.seed)
filename = h.hexdigest()[:20] + '.txt'
return filename
def init_wallet(self):
filename = self.wallet
# file exists
if os.path.isfile(filename):
filefd = open(filename, 'r+')
self.debug(
'Wallet file {0} exists. Opening it...'.format(filename))
for line in filefd:
line = line.rstrip('\n')
addr, index, value, used = line.split(',')
self.debug('reading from file: {0},{1},{2}'.format(
self.s_addr(addr, 3), value, used))
used = used == 'True'
addr = Address(addr, key_index=int(index), security_level=2)
self.addr_dict[addr] = (int(index), int(value), used)
filefd.close()
else:
filefd = open(filename, 'w')
self.debug('Wallet file {0} doesnt exist. Creating it...'.format(
filename))
filefd.close()
def is_empty_wallet(self):
return len(self.addr_dict) == 0
def get_fund_inputs(self, inputs):
total_fund = 0
for addr in inputs:
index, value, used = self.addr_dict[addr]
# TODO: abs. is this right?
total_fund += abs(value)
return total_fund
def write_updates(self):
filefd = open(self.wallet, 'w')
self.debug('Writing (updating) wallet...')
for addr in self.addr_dict:
v = self.addr_dict[addr]
line = 'Writing: {0},{1},{2},{3}\n'.format(self.s_addr(addr), v[0],
v[1], v[2])
self.debug(line)
filefd.write('{0},{1},{2},{3}\n'.format(addr, v[0], v[1], v[2]))
filefd.close()
def update_wallet(self, input_fund, inputs, change_addr):
copy_dict = self.addr_dict.copy()
for addr in inputs:
v = self.addr_dict[addr]
#self.debug('Spending {0} from input {1}'.format(self.s_addr(addr), v))
# Negative fund and used address
new_value = (v[0], -v[1], not v[2])
self.debug('Updating input address {0} to: {1}'.format(
self.s_addr(addr), new_value))
self.addr_dict[addr] = new_value
change_fund = self.get_fund_inputs(inputs) - input_fund
v = self.addr_dict[change_addr]
change_value = (v[0], change_fund, self.NOT_USED)
self.debug('Updating change address {0} to: {1}'.format(
self.s_addr(change_addr), change_value))
self.addr_dict[change_addr] = change_value
self.write_updates()
def enable_debug(self):
self._debug = True
def debug(self, msg):
if self._debug:
print '[+] Debug: ', msg
def get_node_info(self):
return self.api.get_node_info()
def make_addr_list(self, start_index, n):
self.iota_assert(start_index >= 0 and n > 0,
'must be positive numbers. N should be at least 1.')
result = self.api.get_new_addresses(index=start_index, count=n)
addresses = result['addresses']
for i in range(n):
addr = addresses[i]
value = self.get_addr_balance(addr)
# TODO: Why always False
self.addr_dict[addr] = (i, value, False)
self.write_updates()
def get_addr_balance(self, addr):
# TODO: addr is a list with just one element
result = self.api.get_balances([addr])
balance = result['balances']
return (balance[0])
def prepare_transfer(self,
transfer_value,
dest_addr,
tag='DEFAULT',
msg='DEFAULT'):
# TODO: verify address (checksum)
# TODO: use mi, gi, etc
msg = TryteString.from_string(msg)
txn = ProposedTransaction(
address=Address(dest_addr),
message=msg,
tag=Tag(tag),
value=transfer_value,
)
return txn
def find_transactions(self):
addr_list = []
for e in self.addr_dict.items():
addr = e[0]
addr_list.append(addr)
return self.api.findTransactions(addresses=addr_list)['hashes']
def get_bundle(self, trans):
return self.api.getBundles(transaction=trans)
def get_latest_inclusion(self, addrl):
return self.api.get_latest_inclusion(hashes=addrl)
def get_total_fund(self):
total_fund = 0
for addr in self.addr_dict.items():
# key and value from dict
k, v = addr
index, value, used = v
#if not used:
total_fund += value
return total_fund
def get_number_of_address(self):
return len(self.addr_dict)
def is_all_addr_used(self):
for addr in self.addr_dict:
for e in self.addr_dict.items():
addr, v = e
index, value, used = v
if used == False:
return True
def get_more_addr(self, n=10):
start_index = self.get_number_of_address()
self.debug('Getting more addresses...please wait...')
self.make_addr_list(start_index, n)
def send_transfer(self,
input_fund,
inputs,
outputs,
change_addr,
savetofile=True):
# TODO: How to send MANY transactions.
self.debug('Sending {0} transactions, please wait...'.format(
len(outputs)))
self.api.send_transfer(inputs=inputs,
transfers=outputs,
depth=7,
change_address=change_addr,
min_weight_magnitude=self.min_weight_magnitude)
self.debug('Sent.')
if self.is_all_addr_used():
# We do an update to wallet file here.
self.get_more_addr(n=10)
if savetofile:
self.update_wallet(input_fund, inputs, change_addr)
def get_bundles(self, hasht):
return self.api.get_bundles(hasht)
def get_trytes(self, hashl):
return self.api.get_trytes(hashl)['trytes'][0]
def get_transaction_from_trytes(self, trytes):
txn = Transaction.from_tryte_string(trytes)
return txn
def get_transaction_fields(self, txn):
#confirmed = str(txn.is_confirmed)
timestamp = str(txn.timestamp)
address = str(txn.address)
value = str(txn.value)
message = str(txn.signature_message_fragment)
#message = str(txn.message)
tag = str(txn.tag)
return (timestamp, address, value, tag, message)
def get_info_transactions(self, transactions_hashes):
txn_tuples = []
for h in transactions_hashes:
trytes = self.get_trytes([h])
txn = self.get_transaction_from_trytes(trytes)
# Get confirmed flag
li_result = self.get_latest_inclusion([bytes(h)])
confirmed_t = li_result['states'][h]
(_, addr_t, value_t, tag_t,
msg_t) = self.get_transaction_fields(txn)
txn_tuples.append((confirmed_t, addr_t, value_t, tag_t, msg_t))
return txn_tuples
def get_any_valid_addr(self):
#TODO: verify
#return self.addr_dict.keys()[0]
for e in self.addr_dict.items():
addr, v = e
index, value, used = v
if not used:
return addr
return None
def get_inputs(self, fund):
# TODO: Zero fund
fund_sum = 0
addr_list = []
change_addr = None
# Zero fund transactions. We return any addr and any change_addr
if fund == 0:
# TODO: What if it conflicts with one another?
addr_list.append(self.get_any_valid_addr())
change_addr = self.get_any_valid_addr()
return (addr_list, change_addr)
for e in self.addr_dict.items():
addr, v = e
index, value, used = v
if fund_sum < fund:
#if value > 0 and not used:
if value > 0 and used == self.NOT_USED:
fund_sum += value
self.debug(
'Found request: {0}. Found address {1} with fund {2}.'.
format(fund, self.s_addr(addr), value))
addr_list.append(addr)
for e in self.addr_dict.items():
addr, v = e
index, value, used = v
if used == self.NOT_USED and addr not in addr_list:
change_addr = addr
self.debug('Using {0} as change addr.'.format(
self.s_addr(addr)))
break
return (addr_list, change_addr)
#else:
# # TODO
# self.iota_assert(True, 'No change addr available.')
def iota_assert(self, condition, msg):
if not condition:
print 'Error: ', msg
sys.exit(-1)
from iota import Iota
from simplecrypt import decrypt
from base64 import b64decode
from getpass import getpass
import json
# Declare an API object
api = Iota('https://nodes.devnet.iota.org:443', testnet=True)
# Prompt user for tail tx hash of the bundle
tail_hash = input('Tail transaction hash of the bundle: ')
print('Looking for bundle on the Tangle...')
# Fetch bundle
bundle = api.get_bundles(tail_hash)['bundles'][0]
print('Extracting data from bundle...')
# Get all messages from the bundle and concatenate them
b64_encrypted_data = "".join(bundle.get_messages())
# Decode from base64
encrypted_data = b64decode(b64_encrypted_data)
# Prompt for passwword
password = getpass('Password to be used for decryption:')
print('Decrypting data...')
# Decrypt data
# decrypt returns 'bytes' in Python 3, decode it into string
json_data = decrypt(password, encrypted_data).decode('utf-8')
from iota import Iota
from simplecrypt import decrypt
from base64 import b64decode
from getpass import getpass
import json
# Declare an API object
api = Iota('https://nodes.devnet.iota.org:443', devnet=True)
# Prompt user for tail tx hash of the bundle
tail_hash = input('Tail transaction hash of the bundle: ')
print('Looking for bundle on the Tangle...')
# Fetch bundle
bundle = api.get_bundles([tail_hash])['bundles'][0]
print('Extracting data from bundle...')
# Get all messages from the bundle and concatenate them
b64_encrypted_data = "".join(bundle.get_messages())
# Decode from base64
encrypted_data = b64decode(b64_encrypted_data)
# Prompt for passwword
password = getpass('Password to be used for decryption:')
print('Decrypting data...')
# Decrypt data
# decrypt returns 'bytes' in Python 3, decode it into string
json_data = decrypt(password, encrypted_data).decode('utf-8')
def detct():
# for i in range(101):
if GPIO.input(M_pin):
motion = 'Someone is closing'
#print ("Someone is closing!")
# buzzer(M_pin)
else:
GPIO.output(B_pin, GPIO.HIGH)
motion = 'Nobody Here'
#print ("Nobody!")
# time.sleep(2)
t, h = dt11()
s = smoke()
f = flame()
#data = 'Temp: ' + str(t) + '\xb0 | Humi: ' + str(h)+'% | Gas: ' + s+' | Flame: '+ f +' | Motion: ' + motion
data = 'Temp: ' + str(t) + ' | Humi: ' + str(h) + ' | Gas: ' + \
s + ' | Flame: ' + f + ' | Motion: ' + motion
#data = 'abcd'
api = Iota('https://nodes.devnet.iota.org:443', testnet=True)
#address = Address.random(81)
address = Address(
'YEQFOMPOTSQXIDGVULITXSXHQOSRLJIUZB9LKTXRHUM9IHYLWYXZTBMLBZRATRFPUVRVRMSYZPDRMWNMQCTGMTRGSZ'
)
######
######
my_data = TryteString.from_unicode(data)
# Define a zero-value transaction object
# that sends the message to the address
tx = ProposedTransaction(address=address, message=my_data, value=0)
print('Attaching to IOTA')
result = api.send_transfer(transfers=[tx])
txn_hash = result['bundle'].tail_transaction.hash
print('Attached')
print('Transaction Hash:', txn_hash)
# time.sleep(.5)
print('Retriving from IOTA')
bundle = api.get_bundles(txn_hash)
message = bundle['bundles'][0].tail_transaction.signature_message_fragment
output = message.decode()
print('Message:', output)
print('https://explorer.iota.org/devnet/address/' + str(address))
exp = output.split(' ')
if s == 'Gas Leakage' or f == 'Fire! Fire!!' or motion == 'Someone is closing':
buzzer(True)
class TangleConnector:
def __init__(self,
url='https://perma.iota.partners:443',
seed="TESTSEED9"):
self.iri_url = url
self.iota_api = Iota(url, seed)
def get_node(self) -> Dict:
"""
Get IRI node info
"""
try:
res = self.iota_api.get_node_info()
except BadApiResponse as e:
logger.warning("Failed to IRI node info for " + self.iri_url, e)
res = None
return res
def get_tips(self) -> Dict:
"""
Get all unreferenced transactions
"""
try:
res = self.iota_api.get_tips()
except BadApiResponse as e:
logger.warning("Failed to get tips", e)
res = None
return res
def get_hashes_from_addr(self, address: Address) -> List[TransactionHash]:
"""
Get all tx from address
"""
try:
response = self.iota_api.find_transactions(addresses=[address])
hashes = response['hashes']
except (BadApiResponse, KeyError) as e:
logger.warning(
"Failed to get all tx from address " + address.__str__(), e)
hashes = None
return hashes
def get_trytes_from_hashes(
self, hashes: List[TransactionHash]) -> List[TryteString]:
"""
Get tryte signature fragments from hashes
"""
try:
response = self.iota_api.get_trytes(hashes)
trytes = [tryte[0:2187] for tryte in response['trytes']]
except (BadApiResponse, KeyError) as e:
logger.warning("Failed to get all signature fragments", e)
trytes = None
return trytes
def get_all_trytes_from_address(
self, address: Address) -> Dict[TransactionHash, TryteString]:
"""
Get all trytes from address
"""
hashes = self.get_hashes_from_addr(address)
trytes = self.get_trytes_from_hashes(hashes)
if hashes and trytes:
result = dict(zip(hashes, trytes))
else:
result = None
return result
@staticmethod
def get_json_from_tryte(tryte: TryteString) -> Dict:
try:
str_from_tryte = tryte.as_string()
dict_from_tryte = json.loads(str_from_tryte)
except ValueError as e:
logger.error("Failed to convet trytes to JSON", e)
dict_from_tryte = None
return dict_from_tryte
def send_msg_to_addr(self, address: Address, msg: str, tag: str) -> Dict:
"""
Sends msg on Tangle to address with a tag
"""
try:
response = self.iota_api.send_transfer(
depth=2,
transfers=[
ProposedTransaction(address=address,
value=0,
tag=Tag(tag),
message=TryteString.from_string(msg))
])
except BadApiResponse as e:
logger.warning(
"Message '" + msg + "' has failed to be stored in " +
address.__str__(), e)
response = None
return response
def get_bundles_from_addr(self, address: Address) -> List[Dict]:
'''
Retrive all bundles sent to this address from IRI
# requres IRI 1.6+ (or it seems so)
'''
hashes = self.get_hashes_from_addr(address)
bundles = []
if hashes:
for tx in hashes:
try:
# have to loop through all txs, if tx is not 'tail' of a bundle then get_bundles() throws error
bundle = self.iota_api.get_bundles(tx)
except BadApiResponse:
bundle = None
if bundle:
bundles.append(bundle)
return bundles
def get_messages_from_bundles(self, bundles: List) -> Dict:
"""
Loop through list of bundles and get string per bundle
# requres IRI 1.6+ (or it seems so)
"""
output_msgs = {}
for bundle in bundles:
tx_list = bundle['bundles'][0].as_json_compatible()
msg = ''
for tx in tx_list:
# if its a bundle with iotas, just get text from first tx in bundle, the rest are signatures
if tx['current_index'] == 0 and tx['value'] > 0:
msg = tx['signature_message_fragment'].as_string()
break
# if its a bundle without iota value, then consequently get all message fields and join strings
if tx['value'] == 0:
msg = msg + tx['signature_message_fragment'].as_string()
bundle_hash = tx_list[0]['bundle_hash'].__str__()
addr = tx_list[0]['address'].__str__()
timestamp = tx_list[0]['timestamp']
value = tx_list[0]['value']
output_msgs[bundle_hash] = {
'msg': msg,
'address': addr,
'timestamp': timestamp,
'value': value
}
return output_msgs
def get_all_msg_from_addr_by_bundle(self, address: Address) -> Dict:
'''
Get dict of all msg with timestamps from address by bundle hash as key
# requres IRI 1.6+ (or it seems so)
'''
bundles = self.get_bundles_from_addr(address)
hashes_and_msgs = self.get_messages_from_bundles(bundles)
return hashes_and_msgs
