def test_raises_error_if_primary_and_backup_both_failed():
executor = ThreadPoolExecutor(2)
client = jsonrpc.Client("url",
rs=jsonrpc.RequestWithBackups(backups=["url"],
executor=executor))
with pytest.raises(jsonrpc.NetworkError):
assert client.get_currencies()
client = jsonrpc.Client("url",
rs=jsonrpc.RequestWithBackups(backups=["url"],
executor=executor,
fallback=True))
with pytest.raises(jsonrpc.NetworkError):
assert client.get_currencies()
def test_update_last_known_state():
client = jsonrpc.Client("url")
assert client.get_last_known_state() is not None
client.update_last_known_state(2, 2, 2)
assert client.get_last_known_state() is not None
assert client.get_last_known_state().chain_id == 2
assert client.get_last_known_state().version == 2
assert client.get_last_known_state().timestamp_usecs == 2
# chain id mismatch will raise invalid server response instead of
# stale response error
with pytest.raises(jsonrpc.InvalidServerResponse):
client.update_last_known_state(1, 1, 1)
with pytest.raises(jsonrpc.StaleResponseError):
client.update_last_known_state(2, 1, 2)
with pytest.raises(jsonrpc.StaleResponseError):
client.update_last_known_state(2, 2, 1)
with pytest.raises(jsonrpc.StaleResponseError):
client.update_last_known_state(2, 1, 1)
client.update_last_known_state(2, 2, 2)
assert client.get_last_known_state().chain_id == 2
assert client.get_last_known_state().version == 2
assert client.get_last_known_state().timestamp_usecs == 2
client.update_last_known_state(2, 3, 3)
assert client.get_last_known_state().chain_id == 2
assert client.get_last_known_state().version == 3
assert client.get_last_known_state().timestamp_usecs == 3
def get_supported_network_currencies() -> Tuple[str]:
# TODO - error handling
api = jsonrpc.Client(JSON_RPC_URL)
supported_currency_info = api.get_currencies()
return tuple(_.code for _ in supported_currency_info
if _.code == DiemCurrency.XUS)
def __init__(self):
liquidity_custody_account_name = os.getenv(
"LIQUIDITY_CUSTODY_ACCOUNT_NAME", "liquidity")
self.chain_id = int(os.environ["CHAIN_ID"])
self.vasp = Vasp(jsonrpc.Client(os.environ["JSON_RPC_URL"]),
liquidity_custody_account_name)
super().__init__(self.vasp.address_str)
def test_fallback_to_backups_when_primary_failed():
client = jsonrpc.Client(
"primary",
rs=jsonrpc.RequestWithBackups(backups=["backup"],
executor=ThreadPoolExecutor(2),
fallback=True),
)
client._send_http_request = gen_metadata_response(client, fail="primary")
for _ in range(10):
assert client.get_metadata().script_hash_allow_list == ["backup"]
def test_fallback_to_second_if_first_failed():
executor = ThreadPoolExecutor(2)
rs = jsonrpc.RequestWithBackups(backups=["backup"], executor=executor)
client = jsonrpc.Client("primary", rs=rs)
# primary will fail immediately, backup is slow but success
client._send_http_request = gen_metadata_response(client,
fail="primary",
snap="backup")
assert client.get_metadata().script_hash_allow_list == ["backup"]
executor.shutdown()
def test_fallback_strategy_always_returns_primary_response_if_it_successes():
client = jsonrpc.Client(
"primary",
rs=jsonrpc.RequestWithBackups(backups=["backup"],
executor=ThreadPoolExecutor(2),
fallback=True),
)
client._send_http_request = gen_metadata_response(client)
for _ in range(10):
metadata = client.get_metadata()
assert metadata.script_hash_allow_list == ["primary"]
def test_first_success_strategy_returns_first_completed_success_response():
executor = ThreadPoolExecutor(2)
rs = jsonrpc.RequestWithBackups(backups=["backup"], executor=executor)
client = jsonrpc.Client("primary", rs=rs)
client._send_http_request = gen_metadata_response(client, snap="primary")
assert client.get_metadata().script_hash_allow_list == ["backup"]
client._send_http_request = gen_metadata_response(client, snap="backup")
assert client.get_metadata().script_hash_allow_list == ["primary"]
executor.shutdown()
def __init__(self, config: Dict[str, Any]) -> None:
self.sync_interval_ms = config["sync_interval_ms"]
self.accounts = config["accounts"]
self.diem_node_uri = config["diem_node_uri"]
self.progress_file_path = config["progress_file_path"]
self.fetch_batch_size = 10
self.processor = config.get("processor", process_incoming_txn)
logger.info(f"Loaded LRWPubSubClient with config: {config}")
self.client = jsonrpc.Client(self.diem_node_uri)
self.progress = FileProgressStorage(self.progress_file_path)
def sync_db():
client = jsonrpc.Client(JSON_RPC_URL)
onchain_account = client.get_account(VASP_ADDRESS)
up_to_version = (
Transaction.query.filter_by(type=TransactionType.EXTERNAL)
.order_by(desc(Transaction.blockchain_version))
.first()
.blockchain_version
)
if sync_required(onchain_account, up_to_version):
sync(client, onchain_account, up_to_version)
else:
logger.info("balances equal, no synchronization required")
def sync_db():
client = jsonrpc.Client(JSON_RPC_URL)
up_to_version = client.get_metadata().version
onchain_account = client.get_account(VASP_ADDRESS)
transactions_in_db = Transaction.query.filter_by(
type=TransactionType.EXTERNAL)
count = transactions_in_db.count()
if count > 0:
db_latest_version = (transactions_in_db.order_by(
desc(Transaction.blockchain_version)).first().blockchain_version)
if db_latest_version is not None:
up_to_version = db_latest_version
if sync_required(onchain_account, up_to_version):
sync(client, onchain_account, up_to_version)
else:
logger.info("balances equal, no synchronization required")
def from_config(config: config.Config) -> Context:
return Context(
config=config,
jsonrpc_client=jsonrpc.Client(config.json_rpc_url),
custody=stubs.custody.from_env(),
)
args = parser.parse_args()
private_key = args.private_key
auth_key = args.auth_key
refill_amount_human = args.amount
threshold_amount_human = args.threshold
currencies = args.currencies
network_chainid = args.network_chainid
network_json_rpc_url = args.network_json_rpc_url
sleep_interval = args.sleep_interval
if auth_key is None:
print("Must get an authentication key to watch!")
sys.exit(1)
diem_client = jsonrpc.Client(network_json_rpc_url)
watched_account_auth_key = AuthKey(bytes.fromhex(auth_key))
watched_account_addr = watched_account_auth_key.account_address()
watched_account_addr_hex = utils.account_address_hex(watched_account_addr)
refill_amount = int(refill_amount_human) * 1_000_000 # to microdiem
threshold_amount = int(threshold_amount_human) * 1_000_000 # to microdiem
sleep_interval = float(sleep_interval)
while True:
print(f'current datetime: {datetime.now().isoformat().replace("T", " ")}')
for currency in currencies:
currency_balance = next(
b.amount
from diem import jsonrpc, testnet, LocalAccount, utils, stdlib, diem_types
import time
client = jsonrpc.Client(testnet.JSON_RPC_URL)
## wallet method: GETBALANCE
def getBalance(address):
info = client.get_account(address)
return info.balances
def listAccount(parent_vasp, child_vasp, initialBalance):
currency = testnet.TEST_CURRENCY_CODE
seq_num = client.get_account_sequence(parent_vasp.account_address)
raw_txn = diem_types.RawTransaction(
sender=parent_vasp.account_address,
sequence_number=seq_num,
payload=diem_types.TransactionPayload__Script(
stdlib.encode_create_child_vasp_account_script(
coin_type=utils.currency_code(currency),
child_address=child_vasp.account_address,
auth_key_prefix=child_vasp.auth_key.prefix(),
add_all_currencies=False,
child_initial_balance=initialBalance,
)),
max_gas_amount=1_000_000,
gas_unit_price=0,
gas_currency_code=currency,
expiration_timestamp_secs=int(time.time()) + 30,
chain_id=testnet.CHAIN_ID,
)
def to_compact_json(d: dict) -> str:
return json.dumps(d, separators=(",", ":"))
if __name__ == "__main__":
chain = os.getenv("BLOCKCHAIN", "testnet")
if chain == "premainnet":
print(f"Configuring for premainnet (chain ID: {PREMAINNET_CHAIN_ID})")
vasp_private_key = os.environ["LIQUIDITY_ACCOUNT_PRIVATE_KEY"]
account = LocalAccount.from_private_key_hex(vasp_private_key)
json_rpc_url = "https://premainnet.diem.com/v1"
jsonrpc_client = jsonrpc.Client(json_rpc_url)
jsonrpc_client.must_get_account(account.account_address)
print("Premainnet account is valid")
lp_custody_private_keys = to_compact_json(
{liquidity_account_name: vasp_private_key}
)
print(f"Creating {ENV_FILE_NAME} file")
with open(ENV_FILE_NAME, "w") as dotenv:
dotenv.write(f"LIQUIDITY_CUSTODY_ACCOUNT_NAME={liquidity_account_name}\n")
dotenv.write(f"CUSTODY_PRIVATE_KEYS={lp_custody_private_keys}\n")
dotenv.write(f"LIQUIDITY_VASP_ADDR={account.account_address.to_hex()}\n")
dotenv.write(f"JSON_RPC_URL={json_rpc_url}\n")
dotenv.write(f"CHAIN_ID={PREMAINNET_CHAIN_ID}\n")
elif chain == "testnet":
def test_invalid_server_url():
client = jsonrpc.Client("url")
with pytest.raises(jsonrpc.NetworkError):
client.get_currencies()
def __init__(self):
liquidity_custody_account_name = os.getenv(
"LIQUIDITY_CUSTODY_ACCOUNT_NAME", "liquidity")
super().__init__(jsonrpc.Client(JSON_RPC_URL),
liquidity_custody_account_name)
