def contract_update(contract_hash, start=None, end=None):
global contract_dict
global lock
response = ""
# If notification request already present, send it to contractor and set request to "sent"
# TODO: a contract atm can only have one requests, we can change that by using the RPC ids instead
if contract_hash in contract_dict:
with lock:
response = json.dumps(contract_dict[contract_hash])
if contract_dict[contract_hash]["status"] == "finished":
contract_dict[contract_hash]["status"] = "sent"
return response
else:
bound_search = 1
head_level = pytezos.using(shell=network).shell.head.header()["level"]
if end is None:
bound_search = 0
end = head_level
if run_head_level == -1:
Thread(target=read_from_head).start()
try:
# Check contract exists
storage = pytezos.using(
shell=network).contract(contract_hash).storage(head_level)
with lock:
# Make new notification request
contract_dict[contract_hash] = {
"contract_hash": contract_hash,
"status": "in progress",
"data": {},
"bound_search": bound_search
}
if not bound_search:
notification = make_notification(
head_level,
contract_hash,
entrypoint=storage["status"],
storage=storage)
contract_dict[contract_hash]["data"][
head_level] = notification
response = json.dumps(contract_dict[contract_hash])
Thread(target=contract_all_update_search,
args=(contract_hash, ),
kwargs={
"start": start,
"end": end
}).start()
return response
except Exception as e:
print("Error", e)
return {
"error":
"Contract " + contract_hash + " not found. \n" + str(e)
}
def contract_origin_search(contract_hash):
start = 0
end = pytezos.using(shell=network).shell.head.header()["level"]
contract = pytezos.using(shell=network).contract(contract_hash)
found = -1
storage = None
while found == -1:
anchor = int((end + start + 1) / 2)
try:
storage = contract.storage(anchor)
try:
storage = contract.storage(anchor - 1)
end = anchor
except Exception:
found = anchor
except Exception:
start = anchor
if verbose:
print_notification(found,
contract_hash,
entrypoint="contract creation",
storage=storage)
return make_notification(found,
contract_hash,
entrypoint="contract creation",
storage=storage)
def do_include(ctx: Context, prim, args, annots):
path = get_string(args[0])
if isfile(path):
code = Contract.from_file(path).code
else:
parts = path.split(':')
network = parts[0] if len(parts) > 1 else ctx.get('NETWORK', 'mainnet')
address = parts[1] if len(parts) > 1 else parts[0]
assert is_kt(address), f'expected filename or KT address (with network), got {path}'
code = pytezos.using(network).contract(address).contract.code
storage = pytezos.using(network).shell.contracts[address].storage()
ctx.set('STORAGE', storage)
do_interpret(ctx, code)
def get_updates(registry_address,
indexer,
since=None) -> List[Tuple[int, dict]]:
update_levels = get_update_levels(registry_address,
indexer=indexer,
since=since)
with yaspin(
text=f"Retrieving big map diffs since {since or 'origination'}..."
):
baker_registry = pytezos.using('mainnet').contract(registry_address)
def parse_updates(level):
big_map_diff = dict()
opg_list = baker_registry.shell.blocks[level].operations.managers()
for opg in opg_list:
try:
results = baker_registry.operation_result(opg)
for result in results:
print(result.storage)
big_map_diff.update(**result.storage['big_map_0'])
except RpcError:
pass
return level, big_map_diff
with ThreadPoolExecutor(max_workers=10) as executor:
updates = list(executor.map(parse_updates, update_levels))
return updates
def upsert_baker(registry_address,
baker_address,
data,
dry_run=False,
network='mainnet'):
data = encode_info(data)
current_state = get_baker(registry_address=registry_address,
baker_address=baker_address,
network=network,
raw=True)
if current_state:
changes = diff(current_state, data, syntax='symmetric')
log = list(map(format_entry, list(iter_diff(changes))))
fee = UPDATE_FEE
else:
log = [dict(kind='create', address=baker_address)]
fee = CREATE_FEE
with yaspin(text='Generating command line...'):
registry = pytezos.using(shell=network,
key=baker_address).contract(registry_address)
try:
call = registry.set_data(delegate=baker_address,
**data).with_amount(fee)
cmdline = call.cmdline()
except Exception:
exit(-1)
if dry_run:
with yaspin(text='Simulating operation...'):
call.result()
return cmdline, log
def get_snapshot(registry_address,
bakers_addresses: list,
raw=False,
level=None,
network='mainnet') -> dict:
with yaspin(text=f'Retrieving big map snapshot at {level or "head"}...'):
registry = pytezos.using(network).contract(registry_address)
def big_map_get(address):
try:
data = registry.using(
block_id=level or 'head').storage['big_map_0'][address]()
except AssertionError:
data = None
else:
if raw:
for key in ['last_update', 'reporterAccount']:
if key in data:
del data[key]
else:
data = decode_info(data)
return address, data
with ThreadPoolExecutor(max_workers=10) as executor:
snapshot = dict(executor.map(big_map_get, bakers_addresses))
return {k: v for k, v in snapshot.items() if v is not None}
def activate(self, path, network='babylonnet'):
"""
Activates and reveals key from the faucet file
:param path: Path to the .json file downloaded from https://faucet.tzalpha.net/
:param network: Default is Babylonnet
"""
ptz = pytezos.using(key=path, shell=network)
print(f'Activating {ptz.key.public_key_hash()} in the {network}')
if ptz.balance() == 0:
try:
opg = ptz.activate_account().autofill().sign()
print(f'Injecting activation operation:')
pprint(opg.json_payload())
opg.inject(_async=False)
except RpcError as e:
pprint(e)
exit(-1)
else:
print(f'Activation succeeded! Claimed balance: {ptz.balance()} ꜩ')
else:
print('Already activated')
try:
opg = ptz.reveal().autofill().sign()
print(f'Injecting reveal operation:')
pprint(opg.json_payload())
opg.inject(_async=False)
except RpcError as e:
pprint(e)
exit(-1)
else:
print(f'Your key {ptz.key.public_key_hash()} is now active and revealed')
def deploy(self,
path,
storage=None,
network='carthagenet',
key=None,
github_repo_slug=None,
github_oauth_token=None,
dry_run=False):
"""
Deploy contract to the specified network
:param path: Path to the .tz file
:param storage: Storage in JSON format (not Micheline)
:param network:
:param key:
:param github_repo_slug:
:param github_oauth_token:
:param dry_run: Set this flag if you just want to see what would happen
"""
ptz = pytezos.using(shell=network, key=key)
print(
f'Deploying contract using {ptz.key.public_key_hash()} in the {network}'
)
contract = get_contract(path)
if storage is not None:
storage = contract.storage.encode(storage)
try:
opg = ptz.origination(script=contract.script(
storage=storage)).autofill().sign()
print(f'Injecting origination operation:')
pprint(opg.json_payload())
if dry_run:
pprint(opg.preapply())
exit(0)
else:
opg = opg.inject(_async=False)
except RpcError as e:
pprint(e)
exit(-1)
else:
originated_contracts = OperationResult.originated_contracts(opg)
assert len(originated_contracts) == 1
bcd_link = make_bcd_link(network, originated_contracts[0])
print(f'Contract was successfully deployed: {bcd_link}')
if github_repo_slug:
deployment = create_deployment(github_repo_slug,
github_oauth_token,
environment=network)
pprint(deployment)
status = create_deployment_status(
github_repo_slug,
github_oauth_token,
deployment_id=deployment['id'],
state='success',
environment=network,
environment_url=bcd_link)
pprint(status)
def read_secret(self, sess):
k = Key.from_encoded_key(sess['secret'], passphrase=sess['password'])
p = pytezos.using(key=k, shell=sess['network'])
print(k.public_key_hash())
return p
def watch(self, transaction):
client = pytezos.using(shell=self.blockchain.endpoint)
opg = None
i = 300
while True:
try:
# level of the chain latest block
level_position = client.shell.head.metadata(
)['level']['level_position']
opg = self.find_in_past_blocks(client, transaction)
# level_operation = opg['contents'][0]['level'] (not always present)
operation_block_id = opg['branch']
level_operation = client.shell.blocks[
operation_block_id].level()
if level_position - level_operation >= self.blockchain.confirmation_blocks:
logger.info(
f'block was found at a depth of : {level_position - level_operation}'
)
break
except:
if i:
# client.shell.wait_next_block() (might be a better alternative to wait for blocks to append)
time.sleep(2)
i -= 1
else:
raise
func = transaction.function or 'deploy'
sign = (f'{transaction.contract_name}.{func}(*{transaction.args})')
logger.debug(f'{sign}: watch')
transaction.gas = opg['contents'][0]['fee']
result = opg['contents'][0]['metadata']['operation_result']
if 'originated_contracts' in result:
transaction.contract_address = result['originated_contracts'][0]
def activate(_ctx, path: str, network: str) -> None:
ptz = pytezos.using(key=path, shell=network)
logger.info(
'Activating %s in the %s',
ptz.key.public_key_hash(),
network,
)
if ptz.balance() == 0:
try:
opg = ptz.reveal().autofill().sign()
logger.info('Injecting reveal operation:')
logger.info(pformat(opg.json_payload()))
opg.inject(_async=False)
except RpcError as e:
logger.critical(pformat(e))
sys.exit(-1)
else:
logger.info('Activation succeeded! Claimed balance: %s ꜩ',
ptz.balance())
else:
logger.info('Already activated')
try:
opg = ptz.reveal().autofill().sign()
logger.info('Injecting reveal operation:')
logger.info(pformat(opg.json_payload()))
opg.inject(_async=False)
except RpcError as e:
logger.critical(pformat(e))
sys.exit(-1)
else:
logger.info('Your key %s is now active and revealed',
ptz.key.public_key_hash())
def _validate(doc_hash, doc_name, pt=False):
global data
if pt:
from pytezos import pytezos
pytezos = pytezos.using(shell='testnet')
ci = pytezos.contract('KT1DMYxvZCqSVcpea8t6xdVdoDRgPHY3x9sD')
return data.get(doc_hash, {})
def read_mnemonic(self, sess):
k = Key.from_mnemonic(sess['mnemonic'],
passphrase=sess['password'],
email=sess['email'])
p = pytezos.using(key=k, shell=sess['network'])
return p
def check_sync_state():
from apps.wallet.models import Wallet
pytezos_client = pytezos.using(
key=settings.TEZOS_ADMIN_ACCOUNT_PRIVATE_KEY,
shell=settings.TEZOS_NODE)
token_contract = pytezos_client.contract(
settings.TEZOS_TOKEN_CONTRACT_ADDRESS)
fail_message = ""
transfer_transaction_payloads = []
for wallet in Wallet.objects.all():
try:
on_chain_balance = token_contract.big_map_get(
"ledger/{}::{}".format(wallet.address,
wallet.currency.token_id))
if wallet.balance != on_chain_balance:
fail_message += "{} has {} onchain balance but on system {}\n".format(
wallet.wallet_id, on_chain_balance, wallet.balance)
except:
if wallet.balance > 0:
fail_message += "{} has 0 onchain balance but on system {}\n".format(
wallet.wallet_id, wallet.balance)
if len(fail_message) > 0:
raise Exception(fail_message)
return False
else:
return True
def cli(rpc, fishcake_box, fishcake_token):
"""
CLI group
"""
global pytezos, fishcake_box_addr, fishcake_token_addr
pytezos = pytezos.using(shell=rpc)
fishcake_box_addr = fishcake_box
fishcake_token_addr = fishcake_token
def test_sign_verify_message(self, alias, message, block, expected):
client = pytezos.using(key=alias)
sig = client.sign_message(message, block=block)
self.assertEqual(expected, sig)
pytezos.check_message(message,
public_key=client.key.public_key(),
signature=expected,
block=block)
def do_reset(ctx: Context, prim, args, annots):
network = get_string(args[0])
assert network in networks, f'expected on of {", ".join(networks)}, got {network}'
ctx.set('NETWORK', network)
chain_id = ChainID(pytezos.using(network).shell.chains.main.chain_id())
ctx.set('CHAIN_ID', chain_id)
ctx.big_maps.reset()
ctx.drop_all()
def get_contract(path):
path = get_local_contract_path(path)
if path:
contract = ContractInterface.from_file(path)
else:
network, address = path.split(':')
contract = pytezos.using(shell=network).contract(address)
return contract
def __init__(self,
shell="http://localhost:8732",
key="edsk3QoqBuvdamxouPhin7swCvkQNgq4jP5KZPbwWNnwdZpSpJiEbq"):
client: PyTezosClient = pytezos.using(key=key, shell=shell)
self.minter = Minter(client)
self.token = Token(client)
self.quorum = Quorum(client)
self.deploy = Deploy(client)
self.governance = Governance(client)
def get_storage(contract_hash):
# Send contract's storage
storage = None
try:
if block_id is None:
storage = pytezos.using(
shell=network).contract(contract_hash).storage()
else:
storage = pytezos.using(
shell=network).contract(contract_hash).storage(block_id)
except Exception as e:
print("Error", e)
return {"error": str(e)}
if verbose:
print("Get contract storage:", block_id, storage, "\n")
notification = make_notification(block_id, contract_hash, storage=storage)
return json.dumps(notification)
def _get_big_map_val(self, big_map: BigMap, key: StackItem):
key_hash = get_key_hash(key.val_expr, key.type_expr)
network = big_map.val_expr['_network']
try:
res = pytezos.using(network).shell.head.context.big_maps[int(
big_map)][key_hash]()
except JSONDecodeError:
res = None
return res
def createUser(username):
try:
pyt = pytezos.using(key=config["TEZOS_PRIVATE_KEY"],
shell="https://edonet-tezos.giganode.io")
contract = pyt.contract(config["CONTRACT"])
contract.createUser(username).operation_group.sign().inject()
except:
print(
"error in creating user in blockchain. probably it already exists."
)
def do_now(ctx: Context, prim, args, annots):
res = ctx.get('NOW')
if not res:
network = ctx.get('NETWORK')
if network:
now = pytezos.using(network).now()
else:
now = int(datetime.utcnow().timestamp())
res = Timestamp(now)
ctx.push(res, annots=['@now'])
def updateUserPoints(username, points):
try:
pyt = pytezos.using(key=config["TEZOS_PRIVATE_KEY"],
shell="https://edonet-tezos.giganode.io")
contract = pyt.contract(config["CONTRACT"])
contract.updatePoints(username=username,
points=points).operation_group.sign().inject()
except:
print("Tezos error")
def get_contract(path):
if path is None:
files = glob('*.tz')
assert len(files) == 1
contract = ContractInterface.from_file(abspath(files[0]))
elif exists(path):
contract = ContractInterface.from_file(path)
else:
network, address = path.split(':')
contract = pytezos.using(shell=network).contract(address)
return contract
def __init__(self):
self.addresses = []
self.clients = []
for i in sandbox_ids:
key = pytezos.key.from_encoded_key(i)
self.addresses.append(key.public_key_hash())
host = 'tz' if os.getenv('CI') else 'localhost'
self.clients.append(pytezos.using(
key=key,
shell=f'http://{host}:8732',
))
self.client = self.clients[0]
def deploy(
_ctx,
path: str,
storage: Optional[str], # pylint: disable=redefined-outer-name
network: str,
key: Optional[str],
github_repo_slug: Optional[str],
github_oauth_token: Optional[str],
dry_run: bool,
):
ptz = pytezos.using(shell=network, key=key)
logger.info('Deploying contract using %s in the %s',
ptz.key.public_key_hash(), network)
contract = get_contract(path)
try:
opg = ptz.origination(script=contract.script(
initial_storage=storage)).autofill().sign()
logger.info('Injecting origination operation:')
logger.info(pformat(opg.json_payload()))
if dry_run:
logger.info(pformat(opg.preapply()))
sys.exit(0)
else:
opg = opg.inject(_async=False)
except RpcError as e:
logger.critical(pformat(e))
sys.exit(-1)
else:
originated_contracts = OperationResult.originated_contracts(opg)
if len(originated_contracts) != 1:
raise Exception(
'Operation group must has exactly one originated contract')
bcd_link = make_bcd_link(network, originated_contracts[0])
logger.info('Contract was successfully deployed: %s', bcd_link)
if github_repo_slug:
deployment = create_deployment(
github_repo_slug,
github_oauth_token,
environment=network,
)
logger.info(pformat(deployment))
status = create_deployment_status(
github_repo_slug,
github_oauth_token,
deployment_id=deployment['id'],
state='success',
environment=network,
environment_url=bcd_link,
)
logger.info(status)
def get_contract(path):
if path is None:
files = glob('*.tz')
if len(files) != 1:
raise Exception('No contracts found in working directory, specify --path implicitly')
contract = ContractInterface.from_file(abspath(files[0]))
elif exists(path):
contract = ContractInterface.from_file(path)
else:
network, address = path.split(':')
contract = pytezos.using(shell=network).contract(address)
return contract
def read_faucet(self, sess):
faucet = sess['faucet']
#print(faucet)
path = './faucets/{}.json'.format(faucet['pkh'])
with open(path, 'w') as outfile:
json.dump(faucet, outfile)
k = Key.from_faucet(path)
p = pytezos.using(key=k, shell=sess['network'])
return p
def post(self):
try:
payload = v.read_requests(request)
print(payload)
res = requests.get(
"https://api.better-call.dev/v1/contract/mainnet/{}".format(
payload['kt']))
e = res.json()
print(e)
p = pytezos.using(shell='mainnet')
c = p.contract(payload['kt'])
storage = c.storage()
print(storage)
r = requests.post(
'https://37kpt5uorg.execute-api.us-east-1.amazonaws.com/dev/get_ipfs',
{"hash": storage['meta']})
print(r.json())
meta = json.loads(r.json())
print(meta)
storage['goal'] = int(storage['goal'])
storage['achieved'] = int(storage['achieved'])
print(meta['title'])
balance = requests.get(
'https://api.better-call.dev/v1/account/{}/{}'.format(
'mainnet', e['address']))
balance = balance.json()['balance']
return {
'address':
payload['kt'],
'timestamp':
e['timestamp'],
'balance':
int(balance),
'storage':
storage,
'title':
meta['title'],
'description':
meta['description'],
'links':
meta['links'],
'percentage':
round(((int(balance) / 1000000) * 100 / storage['goal']), 2)
}
except:
return 500
