def addressGenerator(seed):
api = Iota(
iotaNode, seed
) # The iota nodes IP address must always be supplied, even if it actually isn't used in this case.
gna_result = api.get_new_addresses(
count=numberOfAddresses
) # This is the function to generate the address.
addresses = gna_result['addresses']
i = 0 #int for number of addresses
#print("Checking seed: " + seed)
while i < numberOfAddresses:
address = [addresses[i]]
#print(" checking address : " + str(address[0]))
i += 1
if address[
0] == known_recieving_value: # If the address is equal to the recieving address then.. (Address without checksum)
print("Bruteforcer Finished")
print("The seed is: " + seed)
file = open("seed.txt", "w") #Open file.
file.write("Bingo. The seed is: " +
seed) #print out bingo and the correct seed.
file.close() #Close the file to save changes.
#if it finds the correct address stop the program.
increment(
seed
) #increase counter by 1 and check if seed needs to be saved into log.
def addressGenerator(seed, iota_node, n_addresses):
api = Iota(iota_node, seed)
gna_result = api.get_new_addresses(
count=n_addresses
) # This is the actual function to generate the addresses
addresses = gna_result['addresses']
total = 0
i = 0
founds = []
while i < n_addresses:
address = [addresses[i]]
balance = addressBalance(address, iota_node)
print("Address " + str(address[0]) + " has a balance of: " +
str(balance))
total += balance
i += 1
if balance:
founds.append(address)
if total > 0:
print("The above addresses have a total balance of " + str(total) +
" Iota tokens!!!")
return founds
else:
print("No balance on those addresses!")
return False
def load_wallet(self, wallet):
config = configparser.ConfigParser()
config.read(wallet)
iota_seed_e = config['wallet']['iotaSeed']
iota_seed = self.key_f.decrypt(
iota_seed_e.encode('utf-8')).decode('utf-8')
api = Iota(self.node, iota_seed)
inputs = api.get_inputs()
addresses = inputs['inputs']
config['wallet']['index'] = str(len(addresses))
if len(addresses) == 0:
print("No address found. Generating...")
gna_result = api.get_new_addresses(count=1)
addresses = gna_result['addresses']
config['wallet']['activeAddress'] = str(addresses[-1])
config['wallet']['totalBalance'] = str(inputs['totalBalance'])
for i, address in enumerate(addresses):
config['addresses']['Address ' + str(i)] = str(address)
with open(wallet, 'w') as configfile:
config.write(configfile)
return api, inputs
class Car:
def __init__(self, seed):
self.api = Iota('https://iotanode.us:443', seed)
def getAddress(self, count=1):
new_address = self.api.get_new_addresses(count=count)
print(new_address)
return new_address
def sendiota(self, address, amount):
self.api.send_transfer(
depth=100,
# One or more :py:class:`ProposedTransaction` objects to add to the
# bundle.
transfers=[
ProposedTransaction(
# Recipient of the transfer.
address=Address(
address,
),
# Amount of IOTA to transfer.
# This value may be zero.
value=amount,
# Optional tag to attach to the transfer.
tag=Tag(b'EXAMPLEK'),
# Optional message to include with the transfer.
message=TryteString.from_string('Hello!'),
),
],
)
def __getAPI(self):
return self.api
class balance():
def __init__(self):
self.seed = seed
self.IOTA_connection = Iota(IOTA_node_URI_conf, seed=seed)
self.mysql_connection = MySQLdb.Connection(host=mysql_conf_hostname,
user=mysql_conf_user,
passwd=mysql_conf_passwd,
db=mysql_conf_db)
self.cursor = self.mysql_connection.cursor()
self.cursor.execute('select trancount from tranCount')
self.trancount = int(self.cursor.fetchone()[0])
addresses = self.getAddresses(addressCount=self.trancount)
balance = self.getBalance(addresses)
iota_to_be_delivered = balance * int(percentage_conf) / 100
print 'balance is: ', balance
print 'percentage for Faucet: ', percentage_conf
print 'iota to be delivered: ', iota_to_be_delivered
#Get balances for a list of addresses
def getBalance(self, addresses):
balances = self.IOTA_connection.get_balances(addresses)
balance = sum(balances['balances'])
return balance
def getAddresses(self, addressCount):
addresses = self.IOTA_connection.get_new_addresses(
count=self.trancount)
addresses_aux = [str(address) for address in addresses['addresses']]
#print len(addresses_aux)
return addresses_aux
def checkAddresses(seed):
# use IOTA api to get first n addresses of the seed
api = Iota(iotaNode, seed)
apiAdresses = api.get_new_addresses(count=numberOfAddresses)
addresses = apiAdresses['addresses']
# check if one of the addresses matches the public known transaction address
i = 0
while i < numberOfAddresses:
address = str([addresses[i]][0])
if (publicTransactionAddress.startswith(address)):
if (numberOfAddresses == 1):
print(
"\nAs we only checked one (i.e. the first) address of a seed, there can only be one result."
)
print(
"Please try to login with the following seed and check your balance:\n\n"
+ seed + "\n")
printDonation()
sys.exit()
else:
print("\nTry to login with this seed (others may follow): " +
seed + "\n")
seedCandidates.append(seed)
i += 1
def get_avl_address():
api = Iota(node, b'NO9SEED9REQUIRED999999999999999999999999999')
# Find the first unused address, starting with index 0:
avl_address = api.get_new_addresses(index=0, count=None)
address = bytes(avl_address['addresses'][0])
return address
def getNewAddress(seed):
# 获取IOTA api函数接口
api = Iota(ip, seed=seed, testnet=True)
# 设置信息传输安全等级
security_level = os.getenv('SECURITY_LEVEL', 1)
# 获取可用的交易地址
address = api.get_new_addresses(
index=0, count=1, security_level=security_level)['addresses'][0]
return str(address)
def get_addr(self):
"""Get an iota address"""
if self.CONFIG['index'] is None:
self.CONFIG['index'] = 0
from iota import Iota
try:
api = Iota(self.CONFIG['node'], self.CONFIG['seed'], 'utf-8')
d = api.get_new_addresses(index=self.CONFIG['index'], count=1)
self.CONFIG['addr'] = str(d['addresses'][-1])
self.debug("Address at index {}: {}".format(
self.CONFIG['index'], self.CONFIG['addr']))
except Exception as e:
print(e)
return False
return True
def addressGenerator():
# Although generating addresses won't connect to the node
api = Iota(node, seed)
gna_result = api.get_new_addresses(index=index,
count=numberOfAddresses,
checksum=True)
addresses = gna_result['addresses']
i = 0
sum = 0
while i < numberOfAddresses:
address = [addresses[i]]
balance = addressBalance(address)
print("Index " + str(index + i) + " address " + str(address[0]) +
" has balance: " + str(balance))
sum += balance
i += 1
print("Above addresses have total balance of " + str(sum) + " iota!")
def test_wireup(self):
"""
Verify that the command is wired up correctly.
The API method indeed calls the appropiate command.
"""
with patch(
'iota.commands.extended.get_new_addresses.GetNewAddressesCommand.__call__',
MagicMock(return_value='You found me!')) as mocked_command:
api = Iota(self.adapter)
# Don't need to call with proper args here.
response = api.get_new_addresses('hashes')
self.assertTrue(mocked_command.called)
self.assertEqual(response, 'You found me!')
def addressGenerator(seed):
api = Iota(
iotaNode, seed
) # The iota nodes IP address must always be supplied, even if it actually isn't used in this case.
gna_result = api.get_new_addresses(
count=numberOfAddresses
) # This is the actual function to generate the address.
addresses = gna_result['addresses']
total = 0
i = 0
while i < numberOfAddresses:
address = [addresses[i]]
balance = addressBalance(address)
print("Address " + str(address[0]) + " has a balance of: " +
str(balance))
total += balance
i += 1
if total > 0:
print("The above addresses have a total balance of " + str(total) +
" Iota tokens!!!")
else:
print("No balance on those addresses!")
def main(uri, index, count):
# type: (Text, int, Optional[int], bool) -> None
seed = get_seed()
# Create the API instance.
# Note: If ``seed`` is null, a random seed will be generated.
api = Iota(uri, seed)
# If we generated a random seed, then we need to display it to the
# user, or else they won't be able to use their new addresses!
if not seed:
print('A random seed has been generated. Press return to see it.')
output_seed(api.seed)
print('Generating addresses. This may take a few minutes...')
print('')
# Here's where all the magic happens!
for addy in api.get_new_addresses(index, count):
print(binary_type(addy).decode('ascii'))
print('')
def generateAddress(self, seed, index):
api_seed = Iota(iotaNodeUrl, seed)
# Here index is used to identify the address(这里index用来标识是第几个地址)
addresses = api_seed.get_new_addresses(index=index, count=1, security_level=2, checksum=True)
address = addresses['addresses'][0]
print('\nThe first available address for your seed: %s' % address)
# coding=utf-8
from iota import Iota
from config_iota_wallet import NODE_URL, SEED
api = Iota(NODE_URL, SEED)
dict_addr = api.get_new_addresses(count=None, index=None)
print("New address: " + str(dict_addr['addresses']))
from iota import Iota, Seed
# Generate a random seed, or use one you already have (for the devnet)
print('Generating a random seed...')
my_seed = Seed.random()
# my_seed = Seed(b'MYCUSTOMSEED')
print('Your seed is: ' + str(my_seed))
# Declare an API object
api = Iota(
adapter='https://nodes.devnet.iota.org:443',
seed=my_seed,
testnet=True,
)
print('Generating the first unused address...')
# Generate the first unused address from the seed
response = api.get_new_addresses()
addy = response['addresses'][0]
print('Your new address is: ' + str(addy))
print('Go to https://faucet.devnet.iota.org/ and enter you address to receive free devnet tokens.')
class Escrow:
def __init__(self, node='https://nodes.thetangle.org:443', seed=None):
#Get Seed
if seed is None:
self.seed = self.getSeed()
else:
self.seed = seed
#Setup API
self.api = Iota(node, self.seed)
#Generates a seed for escrow account
def getSeed(self):
#If no seed, create one
if not os.path.isfile('seed.txt'):
path = pathlib.Path(__file__).parent.absolute()
seed = ''.join([random.choice(LETTERS) for i in range(81)])
open('seed.txt', 'w+').write(seed)
logging.info("Placed new seed in seed.txt")
return open('seed.txt').read().strip().encode('utf-8')
#Creates an escrow holding address
def createEscrow(self):
try:
self.holdingAddress = self.api.get_new_addresses(
count=None, checksum=True)['addresses'][0]
except iota.adapter.BadApiResponse as e:
logging.warning("Bad response from server retrying.")
return self.createEscrow()
return self.holdingAddress
#Waits for a transactions with a refund address
def getRefundAddress(self):
#This is the escrow address
address = self.holdingAddress
try:
#Get Hashes from ledger
txHashes = self.api.find_transactions(addresses=[
address,
])['hashes']
#If no hashes, user has not submitted an address yet.
if len(txHashes) == 0:
return None
else:
#Check messages for a valid address
txs = self.api.get_transaction_objects(
txHashes)['transactions']
for tx in txs:
msg = tx.signature_message_fragment.decode()
try:
self.deposit = Address(msg.strip())
return self.deposit
except:
pass
logging.warning("Invalid address recieved")
except requests.exceptions.ConnectionError as e:
#Sometimes the public nodes will reject a request
print("Error contacting server; retrying")
return self.getRefundAddress()
#Cli version of escrow
def startCli(self, collateral, fee=0, delay=120, deposit=None):
#Create holding address
self.createEscrow()
self.fee = fee
self.collateral = collateral
#Wait for a deposit address to be entered
if self.requestDeposit(collateral, deposit, delay):
while not self.checkCondition():
sleep(3)
self.finalizeEscrow()
#Wait for escrow address to recieve collateral
def requestDeposit(self, collateral, deposit=None, duration=120):
#For CLI prompt a deposit address
if deposit is None:
self.deposit = input("What is the deposit address: ")
print(
f"You have {duration/60:.1f} min to deposit {collateral} IOTA to {self.holdingAddress}"
)
#Wait for escrow to recive collateral funds.
count = 0
while count < duration:
time.sleep(1)
balance = self.getBalance(self.holdingAddress)
if balance >= collateral:
print("Successfully deposited into escrow", balance)
return True
return False
#Condition to release escrow
def checkCondition(self):
#Setup a check condition
#For example RFID or some ledger condition
return True
#Refund user their collateral, remoing the fee
def finalizeEscrow(self, fee=None, deposit=None):
if fee is None: fee = self.fee
if deposit is None: deposit = self.deposit
#Return money to deposit address
returnAmount = self.getBalance(self.holdingAddress)
#Calcualte return amount
if returnAmount > 0:
returnAmount -= fee
#Setup transaction
message = "Repayment of collateral"
feeLocation = self.api.get_new_addresses(count=1,
checksum=True)['addresses'][0]
txs = [
ProposedTransaction(address=Address(deposit),
value=returnAmount,
message=TryteString.from_unicode(message)),
]
#Send transaction
try:
bundle = self.api.send_transfer(transfers=txs)['bundle']
except iota.adapter.BadApiResponse as e:
print("Node did not respond. Retrying.")
return self.finalizeEscrow(fee, deposit)
logging.info(bundle.transactions[0].hash)
logging.info("Sent money back to recipient")
self.addRevenue(fee)
def getBalance(self, address):
try:
response = self.api.get_balances(addresses=[address])['balances']
return response[0]
except requests.exceptions.ConnectionError as e:
logging.info("Error contacting server; retrying")
return self.getBalance(self, address)
#Record the amount of revenue recieved
def addRevenue(self, money, filename='revenue.txt'):
if not os.path.isfile(filename):
open(filename, 'w+').write('0')
current = int(open(filename).read().strip())
current += money
open(filename, 'w+').write(str(current))
#Get the current amount of revenue
def getRevenue(self, filename="revenue.txt"):
if not os.path.isfile(filename): return 0
return int(open(filename).read().strip())
#Send revenue to an address
def sendRevenue(self, outputAddress):
revenue = self.getRevenue()
logger.info(f"Currently have {revenue} revenue.")
message = "Output fees from escrow."
txs = [
ProposedTransaction(address=Address(outputAddress),
value=revenue,
message=TryteString.from_unicode(message)),
]
try:
logger.info("Sending transfer to node.")
bundle = self.api.send_transfer(transfers=txs)['bundle']
except iota.adapter.BadApiResponse as e:
print("Bad api resonse retrying")
return self.sendRevenue(outputAddress)
print(bundle.transactions[0].hash)
from iota import Iota
from iota import ProposedTransaction
from iota import Address
from iota import Tag
from iota import TryteString
from iota.crypto.types import Seed
node1 = 'https://nodes.comnet.thetangle.org:443'
node2 = 'http://localhost:14265'
seed = Seed.random()
print('Your seed is', seed)
api = Iota(node2, seed, testnet=True)
security_level = 2
address = api.get_new_addresses(index=0,
count=1,
security_level=security_level)['addresses'][0]
is_spent = api.were_addresses_spent_from([address])['states'][0]
if is_spent:
print('Address %s is spent!' % address)
else:
print('Your address is: %s' % address)
class Iotapay:
def __init__(self, provider, seed, address=None):
self.seed = seed
self.provider = provider
self.api = Iota(self.provider, self.seed)
def pay(self, data):
try:
json_data = data['json_data']
json_string = json.dumps(json_data)
trytes = TryteString.from_string(json_string)
# Send Transfer
sent_transfer = self.api.send_transfer(
depth=3,
transfers=[
ProposedTransaction(
address=Address(data['to_address']),
value=data['amount'],
tag=Tag(data['tag']),
message=trytes,
),
])
bo = sent_transfer['bundle']
return {
'status': 200,
'transaction_hash': bo.as_json_compatible()[0]['hash_'],
'message': 'Successfully Sent!'
}
except Exception as pe:
# print('pe:', pe)
return {
'status': 400,
'error': '',
# 'balance': str(pe.context['total_balance']),
'message': str(pe).split('(')[0]
}
def get_balance(self, data):
try:
if 'address' in data:
balance_result = self.api.get_balances([data['address']])
balance = balance_result['balances'][0]
else:
gna_result = self.api.get_new_addresses(
index=0, count=50) # generate 50 addresses.
addresses = gna_result['addresses']
balance_result = self.api.get_balances(addresses)
balance = 0
for i in range(len(balance_result['balances'])):
balance = balance + balance_result['balances'][i]
return {
'status': 200,
'balance': balance,
'message': 'Successfully Retrieved!'
}
except Exception as pe:
# print('pe:', pe)
return {
'status': 400,
'error': '',
# 'balance': str(pe.context['total_balance']),
# 'message': str(pe).split('(')[0]
}
def collect(self, data):
print('send request to collect payment.')
return
def generate_invoice(self, data):
print('generate invoice.')
return
class IotaControl:
# init and set startup vars
def __init__(self, config, hjson, index):
self.api = Iota(config.getNodeUrl(), config.getSeed())
self.secLvl = config.getSecLvl()
self.checksum = config.getChecksum()
self.jspath = config.getJsonPath()
self.json = hjson
self.index = index
# generate new address, check if it was spent from
def generate_new_address(self):
if os.path.isfile(self.jspath):
self.index = self.json.get_last_index()
else:
self.index = 0
new_add = self.api.get_new_addresses(index=self.index, count=1, security_level=self.secLvl,
checksum=self.checksum)
print('generating address with index: ', self.index)
self.new_address = str(new_add['addresses'][0])
self.check_spent()
# check if address has spent before
def check_spent(self):
# get rid of the checksum to pass to were_addresses_spent_from
self.address_to_check = [self.new_address[0:81]]
sp = self.api.were_addresses_spent_from(self.address_to_check)
self.spent = sp['states'][0]
print('address has spent before: ', self.spent)
self.write_to_file()
# write to file
def write_to_file(self):
no = self.index
spent = self.spent
address = self.new_address
if os.path.isfile(self.jspath):
self.json.write_json(no, spent, address)
self.index += 1
else:
self.json.construct_json(no, spent, address)
self.index += 1
if spent is True:
self.index += 1
self.generate_new_address()
else:
pass
# Display next unused address of seed stored on IOTA debit card
elif ans == "5":
# Get seed from IOTA debit card
seed = read_seed()
# Create an IOTA object
api = Iota(iotaNode, seed)
print(
"\nGetting next available IOTA address. This may take some time..."
)
# Get next available address without any transactions
result = api.get_new_addresses(index=0,
count=None,
security_level=2)
addresses = result['addresses']
addr = str(addresses[0].with_valid_checksum())
print(
"\nUse the following IOTA address when transfering new funds to IOTA debit card:"
)
print(addr)
# Stop reading/writing to RFID tag
MIFAREReader.MFRC522_StopCrypto1()
# Make sure to stop reading for cards
"""
from iota import Address, ProposedTransaction, Tag, Transaction, Iota, TryteString, json
import pandas as pd
import json
import time
import iota
import threading
##### IOTA SETTINGS #####
SEED = 'PUTYOURSEEDHERE99999999999999999999999999999999999999999999999999'
api = Iota('http://173.212.218.8:14265/',
SEED) # POW node, SEED IS NEEDED TO DO THE SIGNING
tag = iota.Tag('PUTYOURTAGHERE') # Tag for in the message.
address = api.get_new_addresses(
0, 1)['addresses'] # Generates a list of 1 address
##### PANDAS DATA FRAME SET #####
data_frame = pd.DataFrame()
######
def send_to_iota(sensor_data, message):
global data_frame
data_decoded = sensor_data
df1 = pd.DataFrame([data_decoded], columns=data_decoded.keys())
data_frame = pd.concat([data_frame, df1])
print(data_frame)
password = getpass('Please supply a password for encryption:')
print('Encrypting data...')
# Encrypt data
# Note, that in Python 3, encrypt returns 'bytes'
cipher = encrypt(password, json_data)
# Encode to base64, output contains only ASCII chars
b64_cipher = b64encode(cipher)
print('Constructing transaction locally...')
# Convert to trytes
trytes_encrypted_data = TryteString.from_bytes(b64_cipher)
# Generate an address from your seed to post the transfer to
my_address = api.get_new_addresses(index=42)['addresses'][0]
# Tag is optional here
my_tag = Tag(b'CONFIDENTIALINFORMATION')
# Prepare a transaction object
tx = ProposedTransaction(
address=my_address,
value=0,
tag=my_tag,
message=trytes_encrypted_data,
)
print('Sending transfer...')
# Send the transaction to the network
response = api.send_transfer([tx])
def generate_new_address(seed):
# Iota instance
api = Iota(NODE_URL, seed)
address = api.get_new_addresses(count=None, index=None)
return str(address["addresses"][0])
# -*- coding: utf-8 -*-
#füge lokales Verzeichnis hinzu indem pyota installiert wurde
import sys
sys.path.append("/home/pi/.local/lib/python2.7/site-packages")
#importe Iota-Bibliothek um die API anzusprechen
from iota import Iota
import logging
#lokal gespeicherter seed
seed = "DSPOAXMVSC99IUIVJXTIBZFATVFKTCLLJYOLAGSMFJGFXAWEB9GNTQWEDVRYHKIOQF9T9IZY9IVPKTSZK"
url = "https://field.deviota.com:443"
api = Iota(url, seed)
logging.basicConfig(format='%(levelname)s:%(message)s', level=logging.DEBUG)
logger = logging.getLogger(__name__)
api.adapter.set_logger(logger)
gna_result = api.get_new_addresses(count=20)
addresses = gna_result['addresses']
print(addresses)
print("Check Balance...")
gb_result = api.get_balances(addresses)
def genAddrFromSeed(seed, num):
api = Iota('http://localhost:14265', seed)
gna_result = api.get_new_addresses(
count=num) # generates 1 address, starting with index 0
result = gna_result['addresses']
return (result)
class IotaClient(object):
"""Python IOTA client wrapper"""
def __init__(self, seed, provider, depth=5, min_weight_magnitude=14):
self._api = Iota(provider, seed)
self._depth = depth
self._min_weight_magnitude = min_weight_magnitude
self.address = self._get_address()
@staticmethod
def _compose_transaction(address, msg, tag, val):
txn = \
ProposedTransaction(
address=Address(address),
message=TryteString.from_unicode(msg),
tag=Tag(tag),
value=val
)
return txn
def _get_address(self):
address = self._api.get_new_addresses(0, 1)['addresses'][0]
return str(address)
def get_transactions_from_address(self, address):
"""
Gets transaction object from address sorted on timestamp (from latest
to earliest).
:param address:
Address to fetch transaction from
"""
transactions = self._api.find_transactions(addresses=[address])
transaction_hashes = transactions['hashes']
if not transaction_hashes:
raise ValueError("No transactions on address")
trytes = self._api.get_trytes(transaction_hashes)['trytes']
trytes_and_hashes = list(zip(trytes, transaction_hashes))
transactions = list(
map(lambda pair: Transaction.from_tryte_string(pair[0], pair[1]),
trytes_and_hashes))
sorted_transactions = sorted(transactions,
key=lambda t: t.timestamp,
reverse=True)
return sorted_transactions
def get_messages_from_address(self, address):
"""
Gets messages (sorted by timestamp).
Returns a dict with 'json_message' and 'timestamp keys'
:param address:
Address to fetch messages from
"""
sorted_transactions = self.get_transactions_from_address(address)
messages = list(
map(
lambda t: {
'json_message':
json.loads(Fragment.as_string(t.signature_message_fragment)
),
'timestamp':
t.timestamp
}, sorted_transactions))
return messages
@staticmethod
def get_message(transaction):
message = transaction['signature_message_fragment'].decode()
json_message = json.loads(message)
return json_message
def send_transaction(self, address, msg, tag, val):
txn = self._compose_transaction(Address(address), msg, tag, val)
mwm = self._min_weight_magnitude
depth = self._depth
self._api.send_transfer(depth, [txn], None, None, mwm)
class IotaCache(object):
def __init__(self, uri=None, seed=None):
if not uri:
self.uri = "http://localhost:14700"
else:
self.uri = uri
if not seed:
self.seed = 'EBZYNR9YVFIOAZUPQOLRZXPPPIKRCJ9EJKVCXMYVLMNOCCOPYPJKCWUZNLJZZZZWTMVQUXZFYLVLZXJ9Q'
else:
self.seed = seed
self.api = Iota(self.uri, self.seed, testnet=True)
self.mwm = 1
self.depth = 15
def cache_txn_in_tangle_sdk(self, ipfs_addr, tag):
api_response = self.api.get_new_addresses()
addy = api_response['addresses'][0]
address = binary_type(addy).decode('ascii')
result = self.api.send_transfer(
depth=self.depth,
transfers=[
ProposedTransaction(
address=Address(address),
value=0,
tag=Tag(tag),
message=TryteString.from_string(ipfs_addr),
),
],
min_weight_magnitude=self.mwm,
)
return result
def cache_txn_in_tangle_simple(self, data, tag):
address = "JVSVAFSXWHUIZPFDLORNDMASGNXWFGZFMXGLCJQGFWFEZWWOA9KYSPHCLZHFBCOHMNCCBAGNACPIGHVYX"
txns = self.api.get_transactions_to_approve(self.depth)
tr = self.api.get_trytes([txns[u'branchTransaction']])
txn = Transaction.from_tryte_string(tr[u'trytes'][0], txns[u'branchTransaction'])
txn.trunk_transaction_hash = txns[u'trunkTransaction']
txn.branch_transaction_hash = txns[u'branchTransaction']
txn.tag = Tag(TryteString.from_string(tag))
txn.signature_message_fragment = Fragment(TryteString.from_bytes(data))
attach_trytes = attachToTangle(self.uri, txns[u'trunkTransaction'].__str__(), txns[u'branchTransaction'].__str__(), 1, txn.as_tryte_string().__str__())
res = self.api.broadcast_and_store(attach_trytes[u'trytes'])
return res
def cache_txn_in_tangle_message(self, data, tag):
#address = "JVSVAFSXWHUIZPFDLORNDMASGNXWFGZFMXGLCJQGFWFEZWWOA9KYSPHCLZHFBCOHMNCCBAGNACPIGHVYX"
address = "14dD6ygPi5WXdwwBTt1FBZK3aD8uDem1FY"
res = storeMessage(self.uri, address, data, tag)
return res
def get_balance(self, coin_type, account):
address = "JVSVAFSXWHUIZPFDLORNDMASGNXWFGZFMXGLCJQGFWFEZWWOA9KYSPHCLZHFBCOHMNCCBAGNACPIGHVYX"
res = getBalance(self.uri, address, coin_type, account)
return res
def get_approved_txns(self, tag):
ret = []
transactions = self.api.find_transactions(None, None, [tag], None)
if len(transactions['hashes']) == 0:
return ret
tips = self.api.get_tips()
states = self.api.get_inclusion_states(transactions['hashes'], tips['hashes'])
i = 0
for txn in transactions['hashes']:
if states['states'][i] is True:
ret.append(txn)
return ret
def get_non_consumed_txns(self, tag):
ret = []
txn_hashes_all = self.get_approved_txns(tag)
if len(txn_hashes_all) == 0:
return ret
txn_trytes_all = self.api.get_trytes(txn_hashes_all)
consumedSet = []
txn_hashes_consumed = self.api.find_transactions(None, None, [tag+b"CONSUMED"], None)
if len(txn_hashes_consumed['hashes']) != 0:
txn_trytes_consumed = self.api.get_trytes(txn_hashes_consumed['hashes'])
i=0
for txnTrytes in txn_trytes_consumed['trytes']:
txn = Transaction.from_tryte_string(txnTrytes, txn_hashes_consumed['hashes'][i])
i+=1
consumedSet.append(txn.signature_message_fragment)
i=0
for txnTrytes in txn_trytes_all['trytes']:
txn = Transaction.from_tryte_string(txnTrytes, txn_hashes_all[i])
i+=1
if txn.signature_message_fragment not in consumedSet:
msgTryte = txn.signature_message_fragment.decode()
ret.append(msgTryte)
return ret
def set_txn_as_synced(self, ipfs_addr, tag):
result = self.cache_txn_in_tangle_sdk(ipfs_addr, tag+b"CONSUMED")
return result
def add_neighbors(self, uris):
res = addNeighbors(self.uri, uris)
return res
def get_block_content(self, hashes):
res = getBlockContent(self.uri, hashes)
return res
def get_dag(self, dag_type):
res = getDAG(self.uri, dag_type)
return res
def get_utxo(self, dag_type):
res = getUTXO(self.uri, dag_type)
return res
def get_total_order(self):
res = getTotalOrder(self.uri)
return res
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)
import datetime
from operator import itemgetter
from iota import Iota, ProposedTransaction, Address, TryteString, Tag, Transaction
from iota.crypto.addresses import AddressGenerator
from iota.commands.extended.utils import get_bundles_from_transaction_hashes
import iota.commands.extended.get_latest_inclusion
from iota.json import JsonEncoder
# Takes a address (81 Characters) and converts it to an address with checksum (90 Characters)
def address_checksum(address):
bytes_address = bytes(address)
addy = Address(bytes_address)
address = str(addy.with_valid_checksum())
return address
#bitfinex uses cloudflare which blocks many requests; blocking may get triggered at address pregeneration
#uri = "http://iota.bitfinex.com/"
uri = "http://node01.iotatoken.nl:14265/"
index = int(sys.argv[2])
count = None
seed = sys.argv[1]
seed = seed.encode('ascii')
api = Iota(uri, seed)
api_response = api.get_new_addresses(index, count)
for addy in api_response['addresses']:
print(address_checksum(binary_type(addy).decode('ascii')))
#print(binary_type(addy).decode('ascii'))
