def gen_account_bundles_list(account_idx, seed):
# api
api = Iota('http://localhost:14265', seed)
# account info
account_data = api.get_account_data()
bundles = account_data['bundles']
account_bundles_list = \
"""
//!
//! Account 1 Detailed transactions
//!
"""
for i in range(0, len(bundles)):
bundle_idx = i + 1
bundle = bundles[i]
for j in range(0, len(bundle.transactions)):
trx_idx = j + 1
trx = bundle.transactions[j]
account_bundles_list += \
"""
static const std::string ACCOUNT_%s_BUNDLE_%s_TRX_%s_TRYTES = "%s";
""" % (account_idx, bundle_idx, trx_idx, trx.as_tryte_string())
return account_bundles_list
def gen_account_info(account_idx, seed, nb_addrs):
# api connection
api = Iota('http://localhost:14265', seed)
# account info
account_data = api.get_account_data(stop=nb_addrs)
fund = account_data['balance']
addrs = account_data['addresses']
addrs_fund = api.getBalances(addresses=addrs)['balances']
# generate
account_info = \
"""
//!
//! Account %d
//!
static const std::string ACCOUNT_%d_SEED = "%s";
static const int64_t ACCOUNT_%d_FUND = %d;
""" % (account_idx, account_idx, seed, account_idx, fund)
for i in range(0, len(addrs)):
addr_idx = i + 1
account_info += \
"""
static const std::string ACCOUNT_%d_ADDRESS_%d_HASH = "%s";
static const std::string ACCOUNT_%d_ADDRESS_%d_HASH_WITHOUT_CHECKSUM = "%s";
static const int64_t ACCOUNT_%d_ADDRESS_%d_FUND = %d;
""" % (account_idx, addr_idx, addrs[i].with_valid_checksum(), account_idx, addr_idx, addrs[i], account_idx, addr_idx, addrs_fund[i])
return account_info + '\n'
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_account_data.GetAccountDataCommand.__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_account_data()
self.assertTrue(mocked_command.called)
self.assertEqual(response, 'You found me!')
def main():
i=1
print "I start playing the IOTA lottery. Good luck."
##Infinite look how checks the randomly created seeds.
while i>0:
semilla = crea_seed()
## CHANGE THIS - Here you need to include a Full IOTA Node instead localhost
## If you want to try quickly maybe It can be a good idea to install your own
## Full Node
api = Iota('http://*****:*****@gmail.com", "PASSWORD")
text = msg.as_string()
server.sendmail(fromaddr, toaddr, text)
server.quit()
else:
print semilla+ ": " + str(saldo)
'YCXCVQDFGWUKPUABPYNMVPAQUGUHYYLMWZQWRUIDIXGTDAOJKOUGRWDJUUOWGOHMVYLTZHGEZCZHBTMT9RM9XGRJUW'
]
}]
for account in accounts:
# fetch seed
seed = account['seed']
fund = account['fund']
addrs = account['addresses']
# log
print '[%s] Start' % (seed)
# setup iota client
api = Iota('http://localhost:14265', seed)
# attach each address
for address in addrs:
# prepare trx
trx = ProposedTransaction(address=Address(address),
message=TryteString.from_string(
"MSG%s%s" % (seed[:5], address[:5])),
tag=Tag("TAG%s%s" % (seed[:5], address[:5])),
value=0)
# attach
api.send_transfer(1, [trx])
# ensure we can get the expected amount of funding for that account now
api_fund = api.get_account_data(0)['balance']
if api_fund == fund:
print '[%s] Success' % (seed)
else:
print '[%s] Fail: expected %d IOTA, got %d IOTA' % (seed, fund,
api_fund)
import json from iota import Iota from config import SEED, NODE_URL # Iota instance api = Iota(NODE_URL, SEED) # Generate new address print(api.get_account_data())
# Display balance of seed stored on IOTA debit card
elif ans == "4":
# Get seed from IOTA debit card
seed = read_seed()
# Create an IOTA object
api = Iota(iotaNode, seed)
print(
"\nChecking IOTA debit card balance. This may take some time..."
)
# Get balance for the IOTA debit card seed
card_balance = api.get_account_data(start=0, stop=None)
balance = card_balance['balance']
print("\nIOTA debit card balance is: " + str(balance) + " IOTA")
# 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(
from iota import Iota, Seed
from pprint import pprint
import time
# Put your seed from Tutorial 4.a here
my_seed = Seed(b'YOURSEEDFROMTHEPREVIOUSTUTORIAL99999999999999999999999999999999999999999999999999')
# Declare an API object
api = Iota(
adapter='https://nodes.devnet.iota.org:443',
seed=my_seed,
testnet=True
)
# Script actually runs until it finds balance
success = False
while not success:
print('Checking account information on the Tangle...')
# Gather addresses, balance and bundles
response = api.get_account_data()
# response['balance'] is an integer!
if response['balance']:
print('Found the following information based on your seed:')
pprint(response)
success = True
else:
print('Zero balance found, retrying in 30 seconds...')
time.sleep(30)
class IotaClient(object):
def __init__(self):
conf = ConfigParser()
path = os.path.join(os.path.dirname(__file__), 'config/config.txt')
conf.read(path)
self.iota = Iota(conf.get('IOTA', 'node'), conf.get('IOTA', 'seed'))
self.generator = AddressGenerator(self.iota.seed)
self.match_making_addr = self.generator.get_addresses(1)
self.memcached = base.Client(('127.0.0.1', 11211))
def get_addr(self, addr_index):
try:
addr = pickle.loads(self.memcached.get(str(addr_index) + 'addr'))
except TypeError:
addr = self.generator.get_addresses(int(addr_index))[0]
self.memcached.set(str(addr_index) + 'addr', pickle.dumps(addr))
return addr
def send_msg(self, addr_index, msg):
addr = self.get_addr(addr_index)
pt = [
ProposedTransaction(addr,
0,
message=TryteString.from_string(
json.dumps(msg)))
]
msg_hash = str(
self.iota.send_transfer(
depth=1, transfers=pt)['bundle'].transactions[0].hash)
self.add_cached_msg(addr_index, msg, msg_hash)
return msg_hash
def get_msgs(self, addr_index, msg_type=None):
msgs = self.memcached.get(str(addr_index))
try:
msgs = json.loads(msgs.decode())
except (AttributeError, TypeError):
self.memcached.set(str(addr_index), '[]', expire=300)
msgs = self.get_iota_msgs(addr_index)
self.memcached.set(str(addr_index), json.dumps(msgs), expire=300)
if msg_type is not None:
msgs = list(filter(lambda msg: msg['type'] == msg_type, msgs))
return msgs
def get_iota_msgs(self, addr_index):
account_data = self.iota.get_account_data(int(addr_index))
msgs = []
for bundle in account_data['bundles']:
msgs.append(json.loads(bundle.get_messages()[0]))
msgs[-1]['tx_hash'] = str(bundle.transactions[0].hash)
return msgs
def add_cached_msg(self, addr_index, msg, msg_hash):
msgs = self.get_msgs(addr_index)
if any(msg['tx_hash'] == msg_hash for msg in msgs):
return
msgs.append(msg)
msgs[-1]['tx_hash'] = msg_hash
self.memcached.set(str(addr_index), json.dumps(msgs), expire=300)
def save_move(self, addr_index, player, x, y):
return self.send_msg(addr_index, {
'type': 'move',
'player': player,
'x': x,
'y': y
})
def get_moves(self, addr_index):
return self.get_msgs(addr_index, msg_type='move')
def open_match(self):
match_id = randint(100, 1e9)
self.memcached.set('open', str(match_id))
return match_id
def get_open_match(self):
try:
return int(self.memcached.get('open'))
except TypeError:
return None
def close_match(self):
self.memcached.delete('open')
def get_match(self):
match_open = self.get_open_match()
if match_open:
self.close_match()
return match_open, 1
else:
return self.open_match(), 0
def get_account_data(seed):
api = Iota(NODE_URL, seed)
return api.get_account_data()
def get_balances():
api = Iota(node, iota_seed)
iotaBalance = api.get_account_data()['balance']
return iotaBalance
from iota import TryteString
# test data in correct format
testdata = "{\"uid\":\"E24F43FFFE44C2C6\",\"lic\": \"LB-AB-1234\",\"ts\":1606904502}"
#testdata = json.loads(testdata)
# testseed
seed = 'CVBCQHX9MUZZBEAZGOO9GYHWYBEZRMTWNXKBQHNSFETKUPHKHRGUYWLTSGXYAQEVLNI9XTQPTZAGOIUZH'
# devine that we use the devnet
api = Iota('https://nodes.devnet.iota.org:443', seed, testnet=True)
#print(api.get_new_addresses())
# check balance of account
balance = api.get_account_data()
print(balance)
#addresses = []
#addresses.append('SVCSKJPIIAOOSAAYMS9HKQVSIRVCKGOFNVQRTEXJNBFMCYFDIEWWYXBWZQDSKNJCVXCQGS9GUJLBHEAVBNS9UNPGFB')
#balances = api.get_balances(addresses, None)
#print(balances)
# address for output transaction
address = 'OCARSUKVZEZJUKSQU9RIKLANCKHDGCZGELJUUISZTAWQAUXSHHD9RJTKKM9ZMDNDZYFKEBKHEXHBPFAED'
tx = ProposedTransaction(address=Address(address),
value=10,
message=TryteString.from_unicode(testdata))
result = api.send_transfer(transfers=[tx])
print('Bundle: ')
class Wallet:
"""docstring for Wallet"""
def __init__(self, uri: str, seed: Optional[str] = None) -> None:
self._iota_api = Iota(uri, seed)
self._account: _Account
@property
def account(self) -> _Account:
try:
return self._account
except AttributeError:
# We get an attibute error if we check this property before ever
# calling refresh_account.
self.refresh_account()
return self._account
@property
def addresses(self) -> List[Address]:
return self.account.addresses
@property
def balance(self) -> int:
return self.account.balance
@property
def bundles(self) -> Dict[str, Iterable[Bundle]]:
return {
'confirmed': self.account.confirmed_bundles,
'unconfirmed': self.account.unconfirmed_bundles,
'duplicate': self.account.duplicate_bundles,
}
def _is_above_max_depth(self, transaction: Transaction) -> bool:
current_millis = time.time() * 1000
max_age = 11 * 60 * 1000 # 11 minutes
diff = current_millis - cast(float, transaction.attachment_timestamp)
return (0 < diff < max_age)
def _is_promotable(self, bundle: Bundle) -> bool:
return (self._is_above_max_depth(bundle.tail_transaction)
and self._iota_api.helpers.is_promotable(
bundle.tail_transaction.hash))
def _promote(self, bundle: Bundle) -> Bundle:
tail_hash = bundle.tail_transaction.hash
response = self._iota_api.get_latest_inclusion([tail_hash])
if response['states'][tail_hash]:
raise BundleAlreadyPromoted()
response = self._iota_api.promote_transaction(transaction=tail_hash,
depth=DEPTH)
return response['bundle']
def _reattach(self, bundle: Bundle) -> Bundle:
response = self._iota_api.replay_bundle(
bundle.tail_transaction.hash,
DEPTH,
)
return Bundle.from_tryte_strings(response['trytes'])
def create_new_address(self) -> Address:
response = self._iota_api.get_new_addresses(count=None)
address = response['addresses'][0]
# Attach the address
self._iota_api.send_transfer(
depth=DEPTH,
transfers=[ProposedTransaction(address, value=0)],
)
return address
def refresh_account(self) -> None:
response = self._iota_api.get_account_data(inclusion_states=True)
addresses = response['addresses']
balance = response['balance']
bundles = response['bundles']
self._account = _Account(addresses, balance, bundles)
def retry_unconfirmed_bundles(self, *bundles: Bundle) -> None:
if len(bundles) == 0:
bundles = tuple(self.bundles['unconfirmed'])
for bundle in bundles:
print(f'Retrying bundle: {bundle.hash}')
if not self._is_promotable(bundle):
bundle = self._reattach(bundle)
while True:
time.sleep(2)
if self._is_promotable(bundle):
break
for attempt in range(5):
try:
promote_bundle = self._promote(bundle)
except BundleAlreadyPromoted:
break
else:
print(
f'Promotion attempt ({attempt}): Bundle {promote_bundle.hash}'
)
def send(self, address: str, value: int) -> None:
print(f'Sending {value} iota to {address}...')
response = self._iota_api.send_transfer(
depth=DEPTH,
transfers=[ProposedTransaction(Address(address), value=value)])
bundle = response['bundle']
print(f'Iota sent! Bundle hash: {bundle.hash}')
# Clear any fingerprints currently stored in the reader
f.clearDatabase()
# Get seed where fingerprints are stored
MySeed = raw_input("\nWrite or paste seed here: ")
# Define full node to be used when retrieving fingerprints from the tangle
iotaNode = "https://nodes.thetangle.org:443"
# Create an IOTA object
api = Iota(iotaNode, seed=MySeed)
print("\nRetrieving fingerprint characteristics from the tangle..")
# Get seed account data from the tangle
accdata = api.get_account_data(start=0, stop=None)
print("\nUploading fingerprint characteristics to the reader..")
# Get all bundles related to the seed
bundles = accdata['bundles']
# Define bundle counter
i = 0
# For each bundle...
for bundle in bundles:
# Get Bundle message
msg = bundle.get_messages()
from iota.crypto.types import Seed
from iota import Iota
import json, sys
with open('config.json', 'r') as f:
data = json.load(f)
url = data['url']
my_seed = 'GVCLZGQGVIFAFFHIFPFAYWJQLRYHNNUBKNNXIAPHMLOSIAWQTEZUALGAEMGGZRHVBKFHOQUMRZFTUNTH9'
if len(sys.argv) == 2:
my_seed = sys.argv[1]
api = Iota(adapter=url, seed=my_seed)
acount_data = api.get_account_data(start=0)
print(acount_data)
except InvalidUri:
print('Invalid adapter: %s' % args['--adapter'], file=sys.stderr)
sys.exit(-1)
except ValueError as e:
print('Invalid seed: %s - %s' % (args['--seed'], e.args[0]),
file=sys.stderr)
sys.exit(-1)
try:
number = int(args['--number'])
except ValueError as e:
print(e.args[0], file=sys.stderr)
sys.exit(-1)
print('Fetching %d addresses...' % number)
addresses = api.get_account_data(0, number)['addresses']
print('Fetched addresses.')
print('Fetching balances...')
balances = api.get_balances(addresses)['balances']
print('Fetched balances.')
trim = None
total_balance = 0
for index, address, balance in zip(range(0, number), addresses, balances):
total_balance += balance
if trim is None and total_balance != 0:
trim = index
# format: [<index>] - <address><checksum>: <balance>
if args['--list-addresses']:
