def check_other_server_height(self, other_server):
"""To check the height of another server on the same port
rtype: int"""
if isinstance(other_server, Server):
rest.use(self.__class__.network,
custom_seed=other_server.server_seed)
other_server.update_server_blockchain_height()
return other_server
return 0
def update_server_blockchain_height(self):
"""update the server blockchain height\n
return: server_blockchain_height\n
rtype: int\n"""
if rest.cfg.__URL_BASE__ != self.server_seed:
rest.use(self.__class__.network, custom_seed=self.server_seed)
self.server_blockchain_height = rest.GET.api.blocks.getHeight()[
'height']
return int(self.server_blockchain_height)
def __init__(self, server_ip, server_port, server_name=None):
if not server_name:
self.server_name = server_ip
else:
self.server_name = server_name
self.server_ip = server_ip
self.server_port = server_port
self.server_seed = 'http://' + \
str(self.server_ip) + ':' + str(self.server_port)
self.__class__.get_network(server_port)
try:
rest.use(self.__class__.network, custom_seed=self.server_seed)
self.server_blockchain_height = rest.GET.api.blocks.getHeight()[
'height']
def test_loadAccount_badPin(self):
use("dark")
pin = "abc123"
address = "DUGvQBxLzQqrNy68asPcU3stWQyzVq8G49".encode()
privateKey = "123123123"
base = createBase(pin)
dumpAccount(base, address, privateKey)
badPin = "xyz123"
badBase = createBase(badPin)
with self.assertRaises(BadPinError) as context:
loadAccount(badBase)
def test_signTx(self):
"""
Test signing a transaction directly from a ledger wallet
"""
rest.use("dark")
with patch.object(ldgr,
'getDongle',
return_value=MockedHIDDongleHIDAPI()):
tx = dict(vendorField="First Tx using ledger with arky!",
timestamp=int(slots.getTime()),
type=0,
amount=1,
recipientId='DUGvQBxLzQqrNy68asPcU3stWQyzVq8G49',
fee=10000000)
signed_tx = ldgr.signTx(tx, self.path)
assert signed_tx
def test_dumpAccount_findAccounts_loadAccount(self):
use("dark")
pin = "abc123"
address = "DUGvQBxLzQqrNy68asPcU3stWQyzVq8G49".encode()
privateKey = "123123123"
base = createBase(pin)
orig_accounts = findAccounts()
orig_accounts.append("unamed")
dumpAccount(base, address, privateKey)
accounts = findAccounts()
assert set(accounts) == set(orig_accounts)
output = loadAccount(base)
assert output["address"] == address
assert output["privateKey"] == privateKey
def getSelfTransaction(delegate='ravelou'):
selfTransactions = []
sum = 0
arkApi.use('ark') #API initialization
delegateAddress = arkApi.GET.api.delegates.get(
username=delegate)['delegate']['address']
while True:
Transactions = arkApi.GET.api.transactions(recipientId=delegateAddress)
if Transactions["success"]:
receivedTransactions = Transactions['transactions']
break
for elt in receivedTransactions:
if elt['senderId'] == delegateAddress and elt['type'] == 0:
selfTransactions.append(elt['amount'] / 100000000)
for elt in selfTransactions:
sum += elt
print(sum)
def getBlocksBetweenDates(beginDatetime,
endDatetime=datetime.now(pytz.UTC),
delegate='ravelou'):
"""
beginDatetime : the Datetime from where you want to start the counting fees
beginTimetime : not use
delegate : delegate name
"""
limitRecord = 100 #100 : max record you can ask to ark api
offset_rqst = 0 #index used to get more than limit_Record blocks from the ARK API
forgedBlocks = [] #forged blocks before now and after beginDatetime
arkApi.use('ark') #API initialization
delegatePublicKey = arkApi.GET.api.delegates.get(
username=delegate)['delegate']['publicKey']
forgedBlocksRequested = []
while containsAValueAfterDateTime(forgedBlocksRequested, beginDatetime,
endDatetime):
blocksRequest = {}
while not blocksRequest.get("success", False):
blocksRequest = arkApi.GET.api.blocks(
limit=limitRecord,
generatorPublicKey=delegatePublicKey,
offset=offset_rqst)
forgedBlocksRequested = blocksRequest['blocks']
if (arkApi.slots.getRealTime(forgedBlocksRequested[-1]['timestamp']) <=
endDatetime or arkApi.slots.getRealTime(
forgedBlocksRequested[0]['timestamp']) >= beginDatetime):
for i, elt in enumerate(forgedBlocksRequested):
if (arkApi.slots.getRealTime(elt['timestamp']) >= beginDatetime
and arkApi.slots.getRealTime(
elt['timestamp']) <= endDatetime):
forgedBlocks.append(elt)
elif (arkApi.slots.getRealTime(forgedBlocksRequested[0]['timestamp'])
<= endDatetime and arkApi.slots.getRealTime(
forgedBlocksRequested[-1]['timestamp']) >= beginDatetime):
forgedBlocks += forgedBlocksRequested
offset_rqst += limitRecord + 1
return forgedBlocks
def use(param):
if not param["<name>"]:
choices = findNetworks()
if choices:
param["<name>"] = chooseItem("Network(s) found:", *choices)
if not param["<name>"]:
return
else:
sys.stdout.write("No Network found\n")
return False
DATA.initialize()
rest.use(param.get("<name>"),
broadcast=int(param.get("--broadcast", 10)),
timeout=float(param.get("--latency", 5000)) / 1000)
logger = logging.getLogger()
logger.handlers[0].setFormatter(
logging.Formatter('[%s]' % cfg.network + '[%(asctime)s] %(message)s'))
def post_transaction(self,
network,
recipientId,
amount,
secret,
vendorField="",
secondSecret=""):
""" Post a new transaction.
:param network: The network we want to use (ark, dark, ...)
:param recipientId: A valid Ark address.
:param amount: Amount of currency we want to transfer.
:param secret: BIP39 seedpass.
:param vendorField: Optionnal vendorField.
:param secondSecret: Optionnal BIP39 second seedpass.
:return:
"""
rest.use(network)
return arky.core.sendTransaction(recipientId=recipientId,
amount=amount,
vendorField=vendorField,
secret=secret,
secondSecret=secondSecret)
