diff --git a/silkaj/blockchain_tools.py b/silkaj/blockchain_tools.py
index 5c4b2731e7c212b5aff385e0fcfcda10a9c39e40..8957cd1d5ec2fc1a555e773b0b4fd3084cb3ef87 100644
--- a/silkaj/blockchain_tools.py
+++ b/silkaj/blockchain_tools.py
@@ -29,9 +29,9 @@ class BlockchainParams(object):
def __init__(self):
self.params = self.get_params()
- async def get_params(self):
+ def get_params(self):
client = ClientInstance().client
- return await client(blockchain.parameters)
+ return client(blockchain.parameters)
class HeadBlock(object):
@@ -45,6 +45,6 @@ class HeadBlock(object):
def __init__(self):
self.head_block = self.get_head()
- async def get_head(self):
+ def get_head(self):
client = ClientInstance().client
- return await client(blockchain.current)
+ return client(blockchain.current)
diff --git a/silkaj/blocks.py b/silkaj/blocks.py
index 212e6f6653e6c2db5dc600575b7370ba5fd1c9cd..3437f152bc2df3ca1b9b591e21ae25b669a9a6bf 100644
--- a/silkaj/blocks.py
+++ b/silkaj/blocks.py
@@ -14,7 +14,6 @@
# along with Silkaj. If not, see <https://www.gnu.org/licenses/>.
import logging
-from asyncio import sleep
from aiohttp.client_exceptions import ServerDisconnectedError
from click import INT, argument, command, progressbar
@@ -26,7 +25,7 @@ from duniterpy.key.verifying_key import VerifyingKey
from silkaj.constants import BMA_MAX_BLOCKS_CHUNK_SIZE
from silkaj.network_tools import EndPoint
-from silkaj.tools import coroutine, message_exit
+from silkaj.tools import message_exit
@command(
@@ -37,10 +36,9 @@ If nothing specified, the whole blockchain gets verified.",
)
@argument("from_block", default=0, type=INT)
@argument("to_block", default=0, type=INT)
-@coroutine
-async def verify_blocks_signatures(from_block, to_block):
+def verify_blocks_signatures(from_block, to_block):
client = Client(EndPoint().BMA_ENDPOINT)
- to_block = await check_passed_blocks_range(client, from_block, to_block)
+ to_block = check_passed_blocks_range(client, from_block, to_block)
invalid_blocks_signatures = list()
chunks_from = range(from_block, to_block + 1, BMA_MAX_BLOCKS_CHUNK_SIZE)
with progressbar(chunks_from, label="Processing blocks verification") as bar:
@@ -51,28 +49,28 @@ async def verify_blocks_signatures(from_block, to_block):
chunk_from, chunk_from + chunk_size
)
)
- chunk = await get_chunk(client, chunk_size, chunk_from)
+ chunk = get_chunk(client, chunk_size, chunk_from)
for block in chunk:
block = Block.from_signed_raw(block["raw"] + block["signature"] + "\n")
verify_block_signature(invalid_blocks_signatures, block)
- await client.close()
+ client.close()
display_result(from_block, to_block, invalid_blocks_signatures)
-async def check_passed_blocks_range(client, from_block, to_block):
- head_number = (await client(bma.blockchain.current))["number"]
+def check_passed_blocks_range(client, from_block, to_block):
+ head_number = (client(bma.blockchain.current))["number"]
if to_block == 0:
to_block = head_number
if to_block > head_number:
- await client.close()
+ client.close()
message_exit(
"Passed TO_BLOCK argument is bigger than the head block: "
+ str(head_number)
)
if from_block > to_block:
- await client.close()
+ client.close()
message_exit("TO_BLOCK should be bigger or equal to FROM_BLOCK")
return to_block
@@ -86,13 +84,12 @@ def get_chunk_size(from_block, to_block, chunks_from, chunk_from):
return (to_block + 1 - from_block) % BMA_MAX_BLOCKS_CHUNK_SIZE
-async def get_chunk(client, chunk_size, chunk_from):
+def get_chunk(client, chunk_size, chunk_from):
try:
- return await client(bma.blockchain.blocks, chunk_size, chunk_from)
+ return client(bma.blockchain.blocks, chunk_size, chunk_from)
except ServerDisconnectedError:
logging.info("Reach BMA anti-spam protection. Waiting two seconds")
- await sleep(2)
- return await client(bma.blockchain.blocks, chunk_size, chunk_from)
+ return client(bma.blockchain.blocks, chunk_size, chunk_from)
except DuniterError as error:
logging.error(error)
diff --git a/silkaj/cert.py b/silkaj/cert.py
index c8a01c9bd3471b77a979c4c374532b5d535814f9..1d967848a72f0c780c7bc5a46fa850a4dd3d0649 100644
--- a/silkaj/cert.py
+++ b/silkaj/cert.py
@@ -24,26 +24,25 @@ from tabulate import tabulate
from silkaj import tui, wot
from silkaj import wot_tools as wt
from silkaj.auth import auth_method
+from silkaj.tools import message_exit
+from silkaj.network_tools import ClientInstance
from silkaj.blockchain_tools import BlockchainParams, HeadBlock
from silkaj.constants import ALL, DATE, SUCCESS_EXIT_STATUS
from silkaj.crypto_tools import is_pubkey_and_check
from silkaj.license import license_approval
-from silkaj.network_tools import ClientInstance
-from silkaj.tools import coroutine, message_exit
@click.command("cert", help="Send certification")
@click.argument("uid_pubkey_to_certify")
@click.pass_context
-@coroutine
-async def send_certification(ctx, uid_pubkey_to_certify):
+def send_certification(ctx, uid_pubkey_to_certify):
client = ClientInstance().client
checked_pubkey = is_pubkey_and_check(uid_pubkey_to_certify)
if checked_pubkey:
uid_pubkey_to_certify = checked_pubkey
- idty_to_certify, pubkey_to_certify, send_certs = await wot.choose_identity(
+ idty_to_certify, pubkey_to_certify, send_certs = wot.choose_identity(
uid_pubkey_to_certify
)
@@ -51,15 +50,15 @@ async def send_certification(ctx, uid_pubkey_to_certify):
key = auth_method()
issuer_pubkey = key.pubkey
- issuer = await pre_checks(client, issuer_pubkey, pubkey_to_certify)
+ issuer = pre_checks(client, issuer_pubkey, pubkey_to_certify)
# Display license and ask for confirmation
- head = await HeadBlock().head_block
+ head = HeadBlock().head_block
currency = head["currency"]
license_approval(currency)
# Certification confirmation
- await certification_confirmation(
+ certification_confirmation(
ctx, issuer, issuer_pubkey, pubkey_to_certify, idty_to_certify
)
@@ -73,25 +72,25 @@ async def send_certification(ctx, uid_pubkey_to_certify):
if ctx.obj["DISPLAY_DOCUMENT"]:
click.echo(certification.signed_raw(), nl=False)
- await tui.send_doc_confirmation("certification")
+ tui.send_doc_confirmation("certification")
# Sign document
certification.sign([key])
# Send certification document
- response = await client(bma.wot.certify, certification.signed_raw())
+ response = client(bma.wot.certify, certification.signed_raw())
if response.status == 200:
print("Certification successfully sent.")
else:
- print("Error while publishing certification: {0}".format(await response.text()))
+ print("Error while publishing certification: {0}".format(response.text()))
- await client.close()
+ client.close()
-async def pre_checks(client, issuer_pubkey, pubkey_to_certify):
+def pre_checks(client, issuer_pubkey, pubkey_to_certify):
# Check whether current user is member
- issuer = await wt.is_member(issuer_pubkey)
+ issuer = wt.is_member(issuer_pubkey)
if not issuer:
message_exit("Current identity is not member.")
@@ -99,11 +98,11 @@ async def pre_checks(client, issuer_pubkey, pubkey_to_certify):
message_exit("You can’t certify yourself!")
# Check if the certification can be renewed
- req = await client(bma.wot.requirements, pubkey_to_certify)
+ req = client(bma.wot.requirements, pubkey_to_certify)
req = req["identities"][0]
for cert in req["certifications"]:
if cert["from"] == issuer_pubkey:
- params = await BlockchainParams().params
+ params = BlockchainParams().params
# Ğ1: 0<–>2y - 2y + 2m
# ĞT: 0<–>4.8m - 4.8m + 12.5d
renewable = cert["expiresIn"] - params["sigValidity"] + params["sigReplay"]
@@ -118,7 +117,7 @@ async def pre_checks(client, issuer_pubkey, pubkey_to_certify):
return issuer
-async def certification_confirmation(
+def certification_confirmation(
ctx, issuer, issuer_pubkey, pubkey_to_certify, idty_to_certify
):
cert = list()
@@ -126,7 +125,7 @@ async def certification_confirmation(
client = ClientInstance().client
idty_timestamp = idty_to_certify["meta"]["timestamp"]
block_uid_idty = block_uid(idty_timestamp)
- block = await client(bma.blockchain.block, block_uid_idty.number)
+ block = client(bma.blockchain.block, block_uid_idty.number)
timestamp_date = from_timestamp(block["time"], tz="local").format(ALL)
block_uid_date = f": #{idty_timestamp[:15]}… {timestamp_date}"
cert.append(["ID", issuer["uid"], "–>", idty_to_certify["uid"] + block_uid_date])
@@ -138,13 +137,13 @@ async def certification_confirmation(
tui.display_pubkey_and_checksum(pubkey_to_certify),
]
)
- params = await BlockchainParams().params
+ params = BlockchainParams().params
cert_begins = now().format(DATE)
cert_ends = now().add(seconds=params["sigValidity"]).format(DATE)
cert.append(["Valid", cert_begins, "—>", cert_ends])
click.echo(tabulate(cert, tablefmt="fancy_grid"))
if not ctx.obj["DISPLAY_DOCUMENT"]:
- await tui.send_doc_confirmation("certification")
+ tui.send_doc_confirmation("certification")
def docs_generation(currency, pubkey_to_certify, idty_to_certify, issuer_pubkey, head):
diff --git a/silkaj/commands.py b/silkaj/commands.py
index b0647a429fd7c5aedfad48cdbb76e2c8b487e4b9..946eb4b9428db1882a9d707aa00e95e8a3ed9ef2 100644
--- a/silkaj/commands.py
+++ b/silkaj/commands.py
@@ -27,16 +27,15 @@ from pendulum import from_timestamp
from tabulate import tabulate
from silkaj.blockchain_tools import HeadBlock
-from silkaj.constants import ALL, ASYNC_SLEEP, HOUR
+from silkaj.constants import ALL, HOUR
from silkaj.network_tools import ClientInstance, EndPoint
-from silkaj.tools import CurrencySymbol, coroutine
+from silkaj.tools import CurrencySymbol
from silkaj.wot_tools import identity_of
@command("info", help="Display information about currency")
-@coroutine
-async def currency_info():
- head_block = await HeadBlock().head_block
+def currency_info():
+ head_block = HeadBlock().head_block
ep = EndPoint().ep
current_time = from_timestamp(head_block["time"], tz="local")
mediantime = from_timestamp(head_block["medianTime"], tz="local")
@@ -47,7 +46,7 @@ async def currency_info():
"\nCurrent block number:",
head_block["number"],
"\nCurrency name:",
- await CurrencySymbol().symbol,
+ CurrencySymbol().symbol,
"\nNumber of members:",
head_block["membersCount"],
"\nMinimal Proof-of-Work:",
@@ -60,7 +59,7 @@ async def currency_info():
current_time.diff_for_humans(mediantime, True),
)
client = ClientInstance().client
- await client.close()
+ client.close()
def match_pattern(pow, match="", p=1):
@@ -87,17 +86,16 @@ def power(nbr, pow=0):
"diffi",
help="Display the current Proof of Work difficulty level to generate the next block",
)
-@coroutine
-async def difficulties():
+def difficulties():
client = ClientInstance().client
try:
- ws = await client(bma.ws.block)
+ ws = client(bma.ws.block)
while True:
- current = await ws.receive_json()
+ current = ws.receive_json()
jsonschema.validate(current, bma.ws.WS_BLOCK_SCHEMA)
- diffi = await client(bma.blockchain.difficulties)
+ diffi = client(bma.blockchain.difficulties)
display_diffi(current, diffi)
- await client.close()
+ client.close()
except (aiohttp.WSServerHandshakeError, ValueError) as e:
print("Websocket block {0} : {1}".format(type(e).__name__, str(e)))
@@ -145,14 +143,13 @@ Common Proof-of-Work difficulty level: {5}, hash starting with `{6}`\n{7}".forma
is_flag=True,
help="Force detailed view. Compact view happen over 30 blocks",
)
-@coroutine
-async def list_blocks(number, detailed):
- head_block = await HeadBlock().head_block
+def list_blocks(number, detailed):
+ head_block = HeadBlock().head_block
current_nbr = head_block["number"]
if number == 0:
number = head_block["issuersFrame"]
client = ClientInstance().client
- blocks = await client(bma.blockchain.blocks, number, current_nbr - number + 1)
+ blocks = client(bma.blockchain.blocks, number, current_nbr - number + 1)
issuers = list()
issuers_dict = dict()
for block in blocks:
@@ -170,7 +167,7 @@ async def list_blocks(number, detailed):
issuers.append(issuer)
for pubkey in issuers_dict.keys():
issuer = issuers_dict[pubkey]
- idty = await identity_of(issuer["pubkey"])
+ idty = identity_of(issuer["pubkey"])
for issuer2 in issuers:
if (
issuer2.get("pubkey") is not None
@@ -179,8 +176,7 @@ async def list_blocks(number, detailed):
):
issuer2["uid"] = idty["uid"]
issuer2.pop("pubkey")
- await sleep(ASYNC_SLEEP)
- await client.close()
+ client.close()
print(
"Last {0} blocks from n°{1} to n°{2}".format(
number, current_nbr - number + 1, current_nbr
@@ -227,10 +223,9 @@ async def list_blocks(number, detailed):
@command("argos", help="Display currency information formatted for Argos or BitBar")
-@coroutine
-async def argos_info():
- head_block = await HeadBlock().head_block
- currency_symbol = await CurrencySymbol().symbol
+def argos_info():
+ head_block = HeadBlock().head_block
+ currency_symbol = CurrencySymbol().symbol
print(currency_symbol, "|")
print("---")
ep = EndPoint().ep
@@ -262,4 +257,4 @@ async def argos_info():
current_time.diff_for_humans(mediantime, True),
)
client = ClientInstance().client
- await client.close()
+ client.close()
diff --git a/silkaj/constants.py b/silkaj/constants.py
index 04cc3000325232e0beda683f9be83fcee4d203db..e07ce3e7bc04fd98faec819385aa13083d39e721 100644
--- a/silkaj/constants.py
+++ b/silkaj/constants.py
@@ -18,7 +18,6 @@ G1_SYMBOL = "Ğ1"
GTEST_SYMBOL = "ĞTest"
G1_DEFAULT_ENDPOINT = "g1.duniter.org", "443"
G1_TEST_DEFAULT_ENDPOINT = "g1-test.duniter.org", "443"
-ASYNC_SLEEP = 0.15
SUCCESS_EXIT_STATUS = 0
FAILURE_EXIT_STATUS = 1
BMA_MAX_BLOCKS_CHUNK_SIZE = 5000
diff --git a/silkaj/membership.py b/silkaj/membership.py
index 225dd46307f845afda17b0bda0859f7f0665e885..453628c26b3caf6ee9729cf1a1278ed3c95b661b 100644
--- a/silkaj/membership.py
+++ b/silkaj/membership.py
@@ -27,7 +27,6 @@ from silkaj.blockchain_tools import BlockchainParams, HeadBlock
from silkaj.constants import DATE, SUCCESS_EXIT_STATUS
from silkaj.license import license_approval
from silkaj.network_tools import ClientInstance
-from silkaj.tools import coroutine
@click.command(
@@ -36,17 +35,16 @@ from silkaj.tools import coroutine
for first emission and for renewal",
)
@click.pass_context
-@coroutine
-async def send_membership(ctx):
+def send_membership(ctx):
dry_run = ctx.obj["DRY_RUN"]
# Authentication
key = auth.auth_method()
# Get the identity information
- head_block = await HeadBlock().head_block
+ head_block = HeadBlock().head_block
membership_timestamp = BlockUID(head_block["number"], head_block["hash"])
- identity = (await wot.choose_identity(key.pubkey))[0]
+ identity = (wot.choose_identity(key.pubkey))[0]
identity_uid = identity["uid"]
identity_timestamp = block_uid(identity["meta"]["timestamp"])
@@ -57,9 +55,9 @@ async def send_membership(ctx):
# Confirmation
client = ClientInstance().client
- await display_confirmation_table(identity_uid, key.pubkey, identity_timestamp)
+ display_confirmation_table(identity_uid, key.pubkey, identity_timestamp)
if not dry_run and not ctx.obj["DISPLAY_DOCUMENT"]:
- await tui.send_doc_confirmation("membership document for this identity")
+ tui.send_doc_confirmation("membership document for this identity")
membership = generate_membership_document(
currency,
@@ -76,25 +74,25 @@ async def send_membership(ctx):
if dry_run:
click.echo(membership.signed_raw())
- await client.close()
+ client.close()
sys.exit(SUCCESS_EXIT_STATUS)
if ctx.obj["DISPLAY_DOCUMENT"]:
click.echo(membership.signed_raw())
- await tui.send_doc_confirmation("membership document for this identity")
+ tui.send_doc_confirmation("membership document for this identity")
# Send the membership signed raw document to the node
- response = await client(bma.blockchain.membership, membership.signed_raw())
+ response = client(bma.blockchain.membership, membership.signed_raw())
if response.status == 200:
print("Membership successfully sent")
else:
- print("Error while publishing membership: {0}".format(await response.text()))
- logging.debug(await response.text())
- await client.close()
+ print("Error while publishing membership: {0}".format(response.text()))
+ logging.debug(response.text())
+ client.close()
-async def display_confirmation_table(identity_uid, pubkey, identity_timestamp):
+def display_confirmation_table(identity_uid, pubkey, identity_timestamp):
"""
Check whether there is pending memberships already in the mempool
Display their expiration date
@@ -105,7 +103,7 @@ async def display_confirmation_table(identity_uid, pubkey, identity_timestamp):
client = ClientInstance().client
- identities_requirements = await client(bma.wot.requirements, pubkey)
+ identities_requirements = client(bma.wot.requirements, pubkey)
for identity_requirements in identities_requirements["identities"]:
if identity_requirements["uid"] == identity_uid:
membership_expires = identity_requirements["membershipExpiresIn"]
@@ -133,11 +131,11 @@ async def display_confirmation_table(identity_uid, pubkey, identity_timestamp):
table.append(["Block Identity", str(identity_timestamp)[:45] + "…"])
- block = await client(bma.blockchain.block, identity_timestamp.number)
+ block = client(bma.blockchain.block, identity_timestamp.number)
date_idty_pub = pendulum.from_timestamp(block["time"], tz="local").format(DATE)
table.append(["Identity published", date_idty_pub])
- params = await BlockchainParams().params
+ params = BlockchainParams().params
membership_validity = (
pendulum.now().add(seconds=params["msValidity"]).diff_for_humans()
)
diff --git a/silkaj/money.py b/silkaj/money.py
index 4a291f762663d528e5a8c95d934f17476333a85e..e9007b475680434c392d3a7d5ba4f1439ecf709f 100644
--- a/silkaj/money.py
+++ b/silkaj/money.py
@@ -27,15 +27,14 @@ from silkaj.crypto_tools import (
validate_checksum,
)
from silkaj.network_tools import ClientInstance
-from silkaj.tools import CurrencySymbol, coroutine, message_exit
+from silkaj.tools import CurrencySymbol, message_exit
from silkaj.tui import display_amount, display_pubkey_and_checksum
@command("balance", help="Get wallet balance")
@argument("pubkeys", nargs=-1)
@pass_context
-@coroutine
-async def cmd_amount(ctx, pubkeys):
+def cmd_amount(ctx, pubkeys):
client = ClientInstance().client
if not has_auth_method():
@@ -59,34 +58,34 @@ async def cmd_amount(ctx, pubkeys):
total = [0, 0]
for pubkey in pubkeys_list:
- inputs_balance = await get_amount_from_pubkey(pubkey)
- await show_amount_from_pubkey(pubkey, inputs_balance)
+ inputs_balance = get_amount_from_pubkey(pubkey)
+ show_amount_from_pubkey(pubkey, inputs_balance)
total[0] += inputs_balance[0]
total[1] += inputs_balance[1]
if len(pubkeys_list) > 1:
- await show_amount_from_pubkey("Total", total)
+ show_amount_from_pubkey("Total", total)
else:
key = auth_method()
pubkey = key.pubkey
- await show_amount_from_pubkey(pubkey, await get_amount_from_pubkey(pubkey))
- await client.close()
+ show_amount_from_pubkey(pubkey, get_amount_from_pubkey(pubkey))
+ client.close()
-async def show_amount_from_pubkey(label, inputs_balance):
+def show_amount_from_pubkey(label, inputs_balance):
"""
Shows the balance of a pubkey.
`label` can be either a pubkey or "Total".
"""
totalAmountInput = inputs_balance[0]
balance = inputs_balance[1]
- currency_symbol = await CurrencySymbol().symbol
- ud_value = await UDValue().ud_value
- average, monetary_mass = await get_average()
+ currency_symbol = CurrencySymbol().symbol
+ ud_value = UDValue().ud_value
+ average, monetary_mass = get_average()
member = False
# if `pubkey` is a pubkey, get pubkey:checksum and uid
if label != "Total":
- member = await wt.is_member(label)
+ member = wt.is_member(label)
label = display_pubkey_and_checksum(label)
# display balance table
display = list()
@@ -114,16 +113,16 @@ async def show_amount_from_pubkey(label, inputs_balance):
echo(tabulate(display, tablefmt="fancy_grid"))
-async def get_average():
- head = await HeadBlock().head_block
+def get_average():
+ head = HeadBlock().head_block
monetary_mass = head["monetaryMass"]
members_count = head["membersCount"]
average = monetary_mass / members_count
return average, monetary_mass
-async def get_amount_from_pubkey(pubkey):
- listinput, amount = await get_sources(pubkey)
+def get_amount_from_pubkey(pubkey):
+ listinput, amount = get_sources(pubkey)
totalAmountInput = 0
for input in listinput:
@@ -131,10 +130,10 @@ async def get_amount_from_pubkey(pubkey):
return totalAmountInput, amount
-async def get_sources(pubkey):
+def get_sources(pubkey):
client = ClientInstance().client
# Sources written into the blockchain
- sources = await client(tx.sources, pubkey)
+ sources = client(tx.sources, pubkey)
listinput = list()
amount = 0
@@ -152,7 +151,7 @@ async def get_sources(pubkey):
amount += amount_in_current_base(listinput[-1])
# pending source
- history = await client(tx.pending, pubkey)
+ history = client(tx.pending, pubkey)
history = history["history"]
pendings = history["sending"] + history["receiving"] + history["pending"]
@@ -196,11 +195,11 @@ class UDValue(object):
def __init__(self):
self.ud_value = self.get_ud_value()
- async def get_ud_value(self):
+ def get_ud_value(self):
client = ClientInstance().client
- blockswithud = await client(blockchain.ud)
+ blockswithud = client(blockchain.ud)
NBlastUDblock = blockswithud["result"]["blocks"][-1]
- lastUDblock = await client(blockchain.block, NBlastUDblock)
+ lastUDblock = client(blockchain.block, NBlastUDblock)
return lastUDblock["dividend"] * 10 ** lastUDblock["unitbase"]
diff --git a/silkaj/tools.py b/silkaj/tools.py
index 887ed5f8961daf79ecc1c7648fd257c68c905619..267f3597838ccb5066ec7e0df07dfcdf3fd35a37 100644
--- a/silkaj/tools.py
+++ b/silkaj/tools.py
@@ -13,8 +13,6 @@
# You should have received a copy of the GNU Affero General Public License
# along with Silkaj. If not, see <https://www.gnu.org/licenses/>.
-from asyncio import get_event_loop
-from functools import update_wrapper
from sys import exit
from silkaj.blockchain_tools import BlockchainParams
@@ -32,8 +30,8 @@ class CurrencySymbol(object):
def __init__(self):
self.symbol = self.get_symbol()
- async def get_symbol(self):
- params = await BlockchainParams().params
+ def get_symbol(self):
+ params = BlockchainParams().params
if params["currency"] == "g1":
return G1_SYMBOL
elif params["currency"] == "g1-test":
@@ -43,11 +41,3 @@ class CurrencySymbol(object):
def message_exit(message):
print(message)
exit(FAILURE_EXIT_STATUS)
-
-
-def coroutine(f):
- def wrapper(*args, **kwargs):
- loop = get_event_loop()
- return loop.run_until_complete(f(*args, **kwargs))
-
- return update_wrapper(wrapper, f)
diff --git a/silkaj/tui.py b/silkaj/tui.py
index a944eee5450996d101b09eb6cc92b8e2295a314d..b98bdc9b652d92478a5863dbbb681a2eea11432a 100644
--- a/silkaj/tui.py
+++ b/silkaj/tui.py
@@ -40,12 +40,12 @@ def display_amount(tx, message, amount, ud_value, currency_symbol):
)
-async def display_pubkey(tx, message, pubkey):
+def display_pubkey(tx, message, pubkey):
"""
Displays a pubkey and the eventually associated id.
"""
tx.append([message + " (pubkey:checksum)", display_pubkey_and_checksum(pubkey)])
- id = await wot_tools.is_member(pubkey)
+ id = wot_tools.is_member(pubkey)
if id:
tx.append([message + " (id)", id["uid"]])
@@ -62,8 +62,8 @@ def display_pubkey_and_checksum(
return short_pubkey + ":" + ct.gen_checksum(pubkey)
-async def send_doc_confirmation(document_name):
+def send_doc_confirmation(document_name):
if not click.confirm(f"Do you confirm sending this {document_name}?"):
client = network_tools.ClientInstance().client
- await client.close()
+ client.close()
sys.exit(constants.SUCCESS_EXIT_STATUS)
diff --git a/silkaj/tx.py b/silkaj/tx.py
index 5270f8fcc792ab50709013c8fc51719250be8a0b..6ba18b4608a687b7ebd03b76797ca45a590a18e8 100644
--- a/silkaj/tx.py
+++ b/silkaj/tx.py
@@ -14,7 +14,6 @@
# along with Silkaj. If not, see <https://www.gnu.org/licenses/>.
import math
-from asyncio import sleep
from re import compile, search
import click
@@ -31,7 +30,6 @@ from silkaj import money
from silkaj import network_tools as nt
from silkaj import tools, tui
from silkaj.constants import (
- ASYNC_SLEEP,
CENT_MULT_TO_UNIT,
MINIMAL_ABSOLUTE_TX_AMOUNT,
MINIMAL_RELATIVE_TX_AMOUNT,
@@ -102,8 +100,7 @@ Sending to many recipients is possible:\n\
@click.option(
"--yes", "-y", is_flag=True, help="Assume yes. Do not prompt confirmation"
)
-@tools.coroutine
-async def send_transaction(
+def send_transaction(
amounts,
amountsud,
allsources,
@@ -123,12 +120,12 @@ async def send_transaction(
)
# compute amounts and amountsud
if not allsources:
- tx_amounts = await transaction_amount(amounts, amountsud, recipients)
+ tx_amounts = transaction_amount(amounts, amountsud, recipients)
key = auth.auth_method()
issuer_pubkey = key.pubkey
- pubkey_amount = await money.get_amount_from_pubkey(issuer_pubkey)
+ pubkey_amount = money.get_amount_from_pubkey(issuer_pubkey)
if allsources:
if pubkey_amount[0] <= 0:
tools.message_exit(
@@ -148,7 +145,7 @@ async def send_transaction(
if not yes:
confirmation_table = tabulate(
- await gen_confirmation_table(
+ gen_confirmation_table(
issuer_pubkey,
pubkey_amount[0],
tx_amounts,
@@ -162,7 +159,7 @@ async def send_transaction(
if yes or click.confirm(
f"{confirmation_table}\nDo you confirm sending this transaction?"
):
- await handle_intermediaries_transactions(
+ handle_intermediaries_transactions(
key,
issuer_pubkey,
tx_amounts,
@@ -172,10 +169,10 @@ async def send_transaction(
)
else:
client = nt.ClientInstance().client
- await client.close()
+ client.close()
-async def transaction_amount(amounts, UDs_amounts, outputAddresses):
+def transaction_amount(amounts, UDs_amounts, outputAddresses):
"""
Check that the number of passed amounts(UD) and recipients are the same
Returns a list of amounts.
@@ -184,7 +181,7 @@ async def transaction_amount(amounts, UDs_amounts, outputAddresses):
if amounts:
amounts_list = compute_amounts(amounts, CENT_MULT_TO_UNIT)
elif UDs_amounts:
- UD_value = await money.UDValue().ud_value
+ UD_value = money.UDValue().ud_value
amounts_list = compute_amounts(UDs_amounts, UD_value)
if len(amounts_list) != len(outputAddresses) and len(amounts_list) != 1:
tools.message_exit(
@@ -245,7 +242,7 @@ def check_transaction_values(
return outputBackChange
-async def gen_confirmation_table(
+def gen_confirmation_table(
issuer_pubkey,
pubkey_amount,
tx_amounts,
@@ -257,8 +254,8 @@ async def gen_confirmation_table(
Generate transaction confirmation
"""
- currency_symbol = await tools.CurrencySymbol().symbol
- ud_value = await money.UDValue().ud_value
+ currency_symbol = tools.CurrencySymbol().symbol
+ ud_value = money.UDValue().ud_value
total_tx_amount = sum(tx_amounts)
tx = list()
# display account situation
@@ -283,21 +280,20 @@ async def gen_confirmation_table(
ud_value,
currency_symbol,
)
- await tui.display_pubkey(tx, "From", issuer_pubkey)
+ tui.display_pubkey(tx, "From", issuer_pubkey)
# display outputs and amounts
for outputAddress, tx_amount in zip(outputAddresses, tx_amounts):
- await tui.display_pubkey(tx, "To", outputAddress)
- await sleep(ASYNC_SLEEP)
+ tui.display_pubkey(tx, "To", outputAddress)
tui.display_amount(tx, "Amount", tx_amount, ud_value, currency_symbol)
# display last informations
if outputBackChange:
- await tui.display_pubkey(tx, "Backchange", outputBackChange)
+ tui.display_pubkey(tx, "Backchange", outputBackChange)
tx.append(["Comment", comment])
return tx
-async def get_list_input_for_transaction(pubkey, TXamount, outputs_number):
- listinput, amount = await money.get_sources(pubkey)
+def get_list_input_for_transaction(pubkey, TXamount, outputs_number):
+ listinput, amount = money.get_sources(pubkey)
maxInputsNumber = max_inputs_number(outputs_number, NBR_ISSUERS)
# generate final list source
listinputfinal = []
@@ -328,7 +324,7 @@ async def get_list_input_for_transaction(pubkey, TXamount, outputs_number):
return listinputfinal, totalAmountInput, intermediatetransaction
-async def handle_intermediaries_transactions(
+def handle_intermediaries_transactions(
key,
issuers,
tx_amounts,
@@ -340,14 +336,14 @@ async def handle_intermediaries_transactions(
while True:
# consider there is always one backchange output, hence +1
- listinput_and_amount = await get_list_input_for_transaction(
+ listinput_and_amount = get_list_input_for_transaction(
issuers, sum(tx_amounts), len(outputAddresses) + 1
)
intermediatetransaction = listinput_and_amount[2]
if intermediatetransaction:
totalAmountInput = listinput_and_amount[1]
- await generate_and_send_transaction(
+ generate_and_send_transaction(
key,
issuers,
[totalAmountInput],
@@ -355,10 +351,8 @@ async def handle_intermediaries_transactions(
[issuers],
"Change operation",
)
- await sleep(1) # wait 1 second before sending a new transaction
-
else:
- await generate_and_send_transaction(
+ generate_and_send_transaction(
key,
issuers,
tx_amounts,
@@ -367,7 +361,7 @@ async def handle_intermediaries_transactions(
Comment,
OutputbackChange,
)
- await client.close()
+ client.close()
break
@@ -382,7 +376,7 @@ def max_inputs_number(outputs_number, issuers_number):
)
-async def generate_and_send_transaction(
+def generate_and_send_transaction(
key,
issuers,
tx_amounts,
@@ -406,7 +400,7 @@ async def generate_and_send_transaction(
print(" - Total: " + str(sum(tx_amounts) / 100))
client = nt.ClientInstance().client
- transaction = await generate_transaction_document(
+ transaction = generate_transaction_document(
issuers,
tx_amounts,
listinput_and_amount,
@@ -416,12 +410,12 @@ async def generate_and_send_transaction(
)
transaction.sign([key])
- response = await client(process, transaction.signed_raw())
+ response = client(process, transaction.signed_raw())
if response.status == 200:
print("Transaction successfully sent.")
else:
tools.message_exit(
- "Error while publishing transaction: {0}".format(await response.text())
+ "Error while publishing transaction: {0}".format(response.text())
)
@@ -434,7 +428,7 @@ def display_sent_tx(outputAddress, amount):
)
-async def generate_transaction_document(
+def generate_transaction_document(
issuers,
tx_amounts,
listinput_and_amount,
@@ -447,7 +441,7 @@ async def generate_transaction_document(
totalAmountInput = listinput_and_amount[1]
total_tx_amount = sum(tx_amounts)
- head_block = await bt.HeadBlock().head_block
+ head_block = bt.HeadBlock().head_block
currency_name = head_block["currency"]
blockstamp_current = BlockUID(head_block["number"], head_block["hash"])
curentUnitBase = head_block["unitbase"]
diff --git a/silkaj/tx_history.py b/silkaj/tx_history.py
index c9f1554d1d50737f9b3782e1ab271e141f84c582..e9ae0d6e7812b719e6532f2e4bec83bbcb8efd69 100644
--- a/silkaj/tx_history.py
+++ b/silkaj/tx_history.py
@@ -28,7 +28,7 @@ from silkaj.constants import ALL, ALL_DIGITAL
from silkaj.crypto_tools import check_pubkey_format, validate_checksum
from silkaj.money import UDValue, amount_in_current_base, get_amount_from_pubkey
from silkaj.network_tools import ClientInstance
-from silkaj.tools import CurrencySymbol, coroutine
+from silkaj.tools import CurrencySymbol
from silkaj.tui import display_pubkey_and_checksum
@@ -36,34 +36,33 @@ from silkaj.tui import display_pubkey_and_checksum
@argument("pubkey")
@option("--uids", "-u", is_flag=True, help="Display uids")
@option("--full-pubkey", "-f", is_flag=True, help="Display full-length pubkeys")
-@coroutine
-async def transaction_history(pubkey, uids, full_pubkey):
+def transaction_history(pubkey, uids, full_pubkey):
if check_pubkey_format(pubkey):
pubkey = validate_checksum(pubkey)
client = ClientInstance().client
- ud_value = await UDValue().ud_value
- currency_symbol = await CurrencySymbol().symbol
+ ud_value = UDValue().ud_value
+ currency_symbol = CurrencySymbol().symbol
- header = await generate_header(pubkey, currency_symbol, ud_value)
+ header = generate_header(pubkey, currency_symbol, ud_value)
received_txs, sent_txs = list(), list()
- await get_transactions_history(client, pubkey, received_txs, sent_txs)
+ get_transactions_history(client, pubkey, received_txs, sent_txs)
remove_duplicate_txs(received_txs, sent_txs)
- txs_list = await generate_table(
+ txs_list = generate_table(
received_txs, sent_txs, pubkey, ud_value, currency_symbol, uids, full_pubkey
)
table = Texttable(max_width=shutil.get_terminal_size().columns)
table.add_rows(txs_list)
- await client.close()
+ client.close()
echo_via_pager(header + table.draw())
-async def generate_header(pubkey, currency_symbol, ud_value):
+def generate_header(pubkey, currency_symbol, ud_value):
try:
- idty = await wt.identity_of(pubkey)
+ idty = wt.identity_of(pubkey)
except:
idty = dict([("uid", "")])
- balance = await get_amount_from_pubkey(pubkey)
+ balance = get_amount_from_pubkey(pubkey)
return "Transactions history from: {uid} {pubkey}\n\
Current balance: {balance} {currency}, {balance_ud} UD {currency} on {date}\n\
".format(
@@ -76,12 +75,12 @@ Current balance: {balance} {currency}, {balance_ud} UD {currency} on {date}\n\
)
-async def get_transactions_history(client, pubkey, received_txs, sent_txs):
+def get_transactions_history(client, pubkey, received_txs, sent_txs):
"""
Get transaction history
Store txs in Transaction object
"""
- tx_history = await client(history, pubkey)
+ tx_history = client(history, pubkey)
currency = tx_history["currency"]
for received in tx_history["history"]["received"]:
@@ -102,7 +101,7 @@ def remove_duplicate_txs(received_txs, sent_txs):
received_txs.remove(received_tx)
-async def generate_table(
+def generate_table(
received_txs, sent_txs, pubkey, ud_value, currency_symbol, uids, full_pubkey
):
"""
@@ -113,10 +112,10 @@ async def generate_table(
"""
received_txs_table, sent_txs_table = list(), list()
- await parse_received_tx(
+ parse_received_tx(
received_txs_table, received_txs, pubkey, ud_value, uids, full_pubkey
)
- await parse_sent_tx(sent_txs_table, sent_txs, pubkey, ud_value, uids, full_pubkey)
+ parse_sent_tx(sent_txs_table, sent_txs, pubkey, ud_value, uids, full_pubkey)
txs_table = received_txs_table + sent_txs_table
table_titles = [
@@ -132,7 +131,7 @@ async def generate_table(
return txs_table
-async def parse_received_tx(
+def parse_received_tx(
received_txs_table, received_txs, pubkey, ud_value, uids, full_pubkey
):
"""
@@ -147,7 +146,7 @@ async def parse_received_tx(
for received_tx in received_txs:
for issuer in received_tx.issuers:
issuers.append(issuer)
- identities = await wt.identities_from_pubkeys(issuers, uids)
+ identities = wt.identities_from_pubkeys(issuers, uids)
for received_tx in received_txs:
tx_list = list()
tx_list.append(from_timestamp(received_tx.time, tz="local").format(ALL_DIGITAL))
@@ -163,7 +162,7 @@ async def parse_received_tx(
received_txs_table.append(tx_list)
-async def parse_sent_tx(sent_txs_table, sent_txs, pubkey, ud_value, uids, full_pubkey):
+def parse_sent_tx(sent_txs_table, sent_txs, pubkey, ud_value, uids, full_pubkey):
"""
Extract recipients’ pubkeys from outputs
Get identities from pubkeys
@@ -179,7 +178,7 @@ async def parse_sent_tx(sent_txs_table, sent_txs, pubkey, ud_value, uids, full_p
if output_available(output.condition, ne, pubkey):
pubkeys.append(output.condition.left.pubkey)
- identities = await wt.identities_from_pubkeys(pubkeys, uids)
+ identities = wt.identities_from_pubkeys(pubkeys, uids)
for sent_tx in sent_txs:
tx_list = list()
tx_list.append(from_timestamp(sent_tx.time, tz="local").format(ALL_DIGITAL))
diff --git a/silkaj/wot.py b/silkaj/wot.py
index 70c556a65f7c913cdf96637dbb971fc9d85e67d3..eb96533d216af3f32919042dddb51bf3b3101693 100644
--- a/silkaj/wot.py
+++ b/silkaj/wot.py
@@ -26,7 +26,7 @@ from silkaj.blockchain_tools import BlockchainParams
from silkaj.constants import DATE
from silkaj.crypto_tools import is_pubkey_and_check
from silkaj.network_tools import ClientInstance
-from silkaj.tools import coroutine
+from silkaj.tools import message_exit
from silkaj.tui import display_pubkey_and_checksum
@@ -49,25 +49,24 @@ def get_sent_certifications(signed, time_first_block, params):
help="Check received and sent certifications and consult the membership status of any given identity",
)
@click.argument("uid_pubkey")
-@coroutine
-async def received_sent_certifications(uid_pubkey):
+def received_sent_certifications(uid_pubkey):
"""
get searched id
get id of received and sent certifications
display in a table the result with the numbers
"""
client = ClientInstance().client
- first_block = await client(blockchain.block, 1)
+ first_block = client(blockchain.block, 1)
time_first_block = first_block["time"]
checked_pubkey = is_pubkey_and_check(uid_pubkey)
if checked_pubkey:
uid_pubkey = checked_pubkey
- identity, pubkey, signed = await choose_identity(uid_pubkey)
+ identity, pubkey, signed = choose_identity(uid_pubkey)
certifications = OrderedDict()
- params = await BlockchainParams().params
- req = await client(wot.requirements, pubkey)
+ params = BlockchainParams().params
+ req = client(wot.requirements, pubkey)
req = req["identities"][0]
certifications["received_expire"] = list()
certifications["received"] = list()
@@ -102,8 +101,8 @@ async def received_sent_certifications(uid_pubkey):
"✔: Certification available to be written or already written into the blockchain",
)
)
- await membership_status(certifications, pubkey, req)
- await client.close()
+ membership_status(certifications, pubkey, req)
+ client.close()
def cert_written_in_the_blockchain(written_certs, certifieur):
@@ -113,8 +112,8 @@ def cert_written_in_the_blockchain(written_certs, certifieur):
return certifieur["uids"][0]
-async def membership_status(certifications, pubkey, req):
- params = await BlockchainParams().params
+def membership_status(certifications, pubkey, req):
+ params = BlockchainParams().params
if len(certifications["received"]) >= params["sigQty"]:
print(
"Membership expiration due to certification expirations: "
@@ -122,7 +121,7 @@ async def membership_status(certifications, pubkey, req):
len(certifications["received"]) - params["sigQty"]
]
)
- member = await wt.is_member(pubkey)
+ member = wt.is_member(pubkey)
if member:
member = True
print("member:", member)
@@ -152,14 +151,13 @@ def date_approximation(block_id, time_first_block, avgentime):
@click.command("lookup", help="User identifier and public key lookup")
@click.argument("uid_pubkey")
-@coroutine
-async def id_pubkey_correspondence(uid_pubkey):
+def id_pubkey_correspondence(uid_pubkey):
checked_pubkey = is_pubkey_and_check(uid_pubkey)
if checked_pubkey:
uid_pubkey = checked_pubkey
client = ClientInstance().client
- lookups = await wt.wot_lookup(uid_pubkey)
+ lookups = wt.wot_lookup(uid_pubkey)
await client.close()
content = f"Public keys or user id found matching '{uid_pubkey}':\n"
@@ -170,14 +168,14 @@ async def id_pubkey_correspondence(uid_pubkey):
click.echo(content)
-async def choose_identity(pubkey_uid):
+def choose_identity(pubkey_uid):
"""
Get lookup from a pubkey or an uid
Loop over the double lists: pubkeys, then uids
If there is one uid, returns it
If there is multiple uids, prompt a selector
"""
- lookups = await wt.wot_lookup(pubkey_uid)
+ lookups = wt.wot_lookup(pubkey_uid)
# Generate table containing the choices
identities_choices = {"id": [], "uid": [], "pubkey": [], "timestamp": []}
diff --git a/silkaj/wot_tools.py b/silkaj/wot_tools.py
index 3b617d6ccf316fbb4867a7c8b333ae8177e3988c..b74248efbcb2f0fb305788caeb7b3ea611dc67b9 100644
--- a/silkaj/wot_tools.py
+++ b/silkaj/wot_tools.py
@@ -13,17 +13,14 @@
# You should have received a copy of the GNU Affero General Public License
# along with Silkaj. If not, see <https://www.gnu.org/licenses/>.
-from asyncio import sleep
-
from duniterpy.api.bma import wot
from duniterpy.api.errors import DuniterError
-from silkaj.constants import ASYNC_SLEEP
from silkaj.network_tools import ClientInstance
from silkaj.tools import message_exit
-async def identity_of(pubkey_uid):
+def identity_of(pubkey_uid):
"""
Only works for members
Not able to get corresponding uid from a non-member identity
@@ -31,23 +28,23 @@ async def identity_of(pubkey_uid):
"""
client = ClientInstance().client
try:
- return await client(wot.identity_of, pubkey_uid)
+ return client(wot.identity_of, pubkey_uid)
except ValueError as e:
pass
-async def is_member(pubkey_uid):
+def is_member(pubkey_uid):
"""
Check identity is member
If member, return corresponding identity, else: False
"""
try:
- return await identity_of(pubkey_uid)
+ return identity_of(pubkey_uid)
except:
return False
-async def wot_lookup(identifier):
+def wot_lookup(identifier):
"""
:identifier: identity or pubkey in part or whole
Return received and sent certifications lists of matching identities
@@ -55,7 +52,7 @@ async def wot_lookup(identifier):
"""
client = ClientInstance().client
try:
- results = await client(wot.lookup, identifier)
+ results = client(wot.lookup, identifier)
return results["results"]
except DuniterError as e:
message_exit(e.message)
@@ -63,7 +60,7 @@ async def wot_lookup(identifier):
pass
-async def identities_from_pubkeys(pubkeys, uids):
+def identities_from_pubkeys(pubkeys, uids):
"""
Make list of pubkeys unique, and remove empty strings
Request identities
@@ -75,8 +72,7 @@ async def identities_from_pubkeys(pubkeys, uids):
identities = list()
for pubkey in uniq_pubkeys:
try:
- identities.append(await identity_of(pubkey))
+ identities.append(identity_of(pubkey))
except Exception as e:
pass
- await sleep(ASYNC_SLEEP)
return identities