You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
167 lines
4.5 KiB
167 lines
4.5 KiB
|
|
import argparse
|
|
import asyncio
|
|
import math
|
|
import json
|
|
import random
|
|
|
|
from dataclasses import dataclass
|
|
from multiprocessing import Pool
|
|
from functools import partial
|
|
from time import time
|
|
|
|
import aiohttp
|
|
import monero
|
|
|
|
|
|
# openmonero backend url
|
|
om_url = "http://127.0.0.1:1984/"
|
|
#om_url = "http://139.162.60.17:1984/"
|
|
|
|
|
|
async def make_request(url, payload=""):
|
|
|
|
headers = {'content-type': "application/json",
|
|
'cache-control': "no-cache"}
|
|
|
|
async with aiohttp.ClientSession(headers=headers) as session:
|
|
async with session.post(url, data=json.dumps(payload)) as response:
|
|
if response.status == 200:
|
|
result = await response.json()
|
|
print(result)
|
|
return result
|
|
|
|
@dataclass
|
|
class OpenMonero:
|
|
|
|
address: str
|
|
viewkey: str
|
|
url: str = om_url
|
|
|
|
def __post_init__(self):
|
|
self.payload = {"address": self.address,
|
|
"view_key": self.viewkey}
|
|
|
|
async def get_version(self):
|
|
return await make_request(om_url+"get_version")
|
|
|
|
async def login(self):
|
|
payload = dict(self.payload,
|
|
**{"create_account":False,
|
|
"generated_locally":False})
|
|
return await make_request(self.url+"login", payload)
|
|
|
|
async def import_recent_wallet(self, no_blocks=100000):
|
|
payload = dict(self.payload,
|
|
**{"no_blocks_to_import":str(no_blocks)})
|
|
return await make_request(self.url
|
|
+"import_recent_wallet_request", payload)
|
|
|
|
async def import_wallet(self):
|
|
return await make_request(self.url
|
|
+"import_wallet_request", self.payload)
|
|
|
|
async def get_address_txs(self):
|
|
return await make_request(self.url+"get_address_txs",
|
|
self.payload)
|
|
|
|
async def get_address_info(self):
|
|
return await make_request(self.url+"get_address_info",
|
|
self.payload)
|
|
|
|
|
|
def new_address(n, net_type='stagenet'):
|
|
# n is not used
|
|
s = monero.seed.Seed()
|
|
s_address = s.public_address(net_type)
|
|
s_viewkey = s.secret_view_key()
|
|
return str(s_address), s_viewkey
|
|
|
|
|
|
def pool_address_generator(n=10,net_type='stagenet'):
|
|
new_address_part = partial(new_address, net_type=net_type)
|
|
with Pool(5) as p:
|
|
return p.map(new_address_part, range(n))
|
|
|
|
|
|
async def apool_address_gen(no_of_chunnks,chunck_size=5,
|
|
net_type='stagenet'):
|
|
loop = asyncio.get_running_loop()
|
|
for i in range(no_of_chunnks):
|
|
yield await loop.run_in_executor(
|
|
None, pool_address_generator, chunck_size, net_type)
|
|
|
|
|
|
async def create_tasks(n=10, net_type='stagenet'):
|
|
|
|
requests_list = []
|
|
|
|
chunck_size = 5;
|
|
no_of_chunnks = math.ceil(n/chunck_size);
|
|
|
|
ct = asyncio.create_task
|
|
|
|
i = 1;
|
|
|
|
async for addresses in apool_address_gen(
|
|
no_of_chunnks, net_type=net_type):
|
|
|
|
for s_address, s_viewkey in addresses:
|
|
|
|
print(f"\n{i}/{n}: {s_address}")
|
|
|
|
om = OpenMonero(s_address, s_viewkey)
|
|
|
|
requests_list.append(ct(om.get_version()))
|
|
requests_list.append(ct(om.login()))
|
|
requests_list.append(ct(om.import_wallet()))
|
|
requests_list.append(ct(om.import_recent_wallet()))
|
|
requests_list.append(ct(om.get_address_txs()))
|
|
requests_list.append(ct(om.get_address_info()))
|
|
|
|
i = i + 1
|
|
|
|
return await asyncio.gather(*requests_list)
|
|
|
|
|
|
async def main():
|
|
|
|
parser = argparse.ArgumentParser(
|
|
description='OpenMonero account imports.')
|
|
|
|
parser.add_argument("-n", "--number",
|
|
help="number of accounts to import", type=int,
|
|
default=1)
|
|
|
|
parser.add_argument("-b", "--blocks",
|
|
help="number of recent blocks to import", type=int,
|
|
default=100000)
|
|
|
|
parser.add_argument("-t", "--testnet",
|
|
help="testnet network", action="store_true")
|
|
|
|
parser.add_argument("-s", "--stagenet",
|
|
help="stagenet network", action="store_true")
|
|
|
|
parser.add_argument("-m", "--mainnet",
|
|
help="mainnet network", action="store_true")
|
|
|
|
args = parser.parse_args()
|
|
|
|
net_type = "stagenet"
|
|
|
|
if args.testnet:
|
|
net_type = "testnet"
|
|
|
|
if args.mainnet:
|
|
net_type = "mainnet"
|
|
|
|
await create_tasks(args.number, net_type)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
t_start = time()
|
|
asyncio.run(main())
|
|
t_end = time()
|
|
print(f"\n\n[+] {t_end - t_start} seconds elapsed.")
|