def resolve(name: str, proxy: ElrondProxy) -> Address:
name_arg = "0x{}".format(str.encode(name).hex())
dns_address = dns_address_for_name(name)
contract = SmartContract(dns_address)
result = contract.query(proxy, "resolve", [name_arg])
if len(result) == 0:
return Address.zero()
return Address(result[0].hex)
def registration_cost(shard_id: int, proxy: ElrondProxy) -> int:
dns_address = compute_dns_address_for_shard_id(shard_id)
contract = SmartContract(dns_address)
result = contract.query(proxy, "getRegistrationCost", [])
if len(result[0]) == 0:
return 0
else:
return int("0x{}".format(result[0]))
def query(args: Any):
logger.debug("query")
contract_address = args.contract
function = args.function
arguments = args.arguments
contract = SmartContract(contract_address)
result = contract.query(ElrondProxy(args.proxy), function, arguments)
utils.dump_out_json(result)
def compute_dns_address_for_shard_id(shard_id) -> Address:
deployer_pubkey_prefix = InitialDNSAddress[:len(InitialDNSAddress) -
ShardIdentiferLen]
deployer_pubkey = deployer_pubkey_prefix + bytes([0, shard_id])
deployer = Account(address=Address(deployer_pubkey))
deployer.nonce = 0
# Workaround: currently, in erdpy, in order to compute the address of a contract, one has to create an instance of the class "SmartContract".
# This might change in the future.
contract = SmartContract()
contract.owner = deployer
contract.compute_address()
return contract.address
def deploy_smart_contract(args):
logger.debug("deploy_smart_contract")
project_directory = args.project
pem_file = args.pem
proxy_url = args.proxy
arguments = args.arguments
gas_price = args.gas_price
gas_limit = args.gas_limit
value = args.value
metadata_upgradeable = args.metadata_upgradeable
# TODO: apply guards
project = load_project(project_directory)
bytecode = project.get_bytecode()
metadata = CodeMetadata(metadata_upgradeable)
contract = SmartContract(bytecode=bytecode, metadata=metadata)
environment = TestnetEnvironment(proxy_url)
owner = Account(pem_file=pem_file)
def flow():
tx_hash, address = environment.deploy_contract(contract, owner,
arguments, gas_price,
gas_limit, value)
logger.info("Tx hash: %s", tx_hash)
logger.info("Contract address: %s", address)
utils.dump_out_json({
"tx": tx_hash,
"contract": address.bech32()
}, args.outfile)
environment.run_flow(flow)
def upgrade_smart_contract(args):
logger.debug("upgrade_smart_contract")
contract_address = args.contract
project_directory = args.project
pem_file = args.pem
proxy_url = args.proxy
arguments = args.arguments
gas_price = args.gas_price
gas_limit = args.gas_limit
value = args.value
metadata_upgradeable = args.metadata_upgradeable
project = load_project(project_directory)
bytecode = project.get_bytecode()
metadata = CodeMetadata(metadata_upgradeable)
contract = SmartContract(contract_address,
bytecode=bytecode,
metadata=metadata)
environment = TestnetEnvironment(proxy_url)
caller = Account(pem_file=pem_file)
def flow():
tx_hash = environment.upgrade_contract(contract, caller, arguments,
gas_price, gas_limit, value)
logger.info("Tx hash: %s", tx_hash)
environment.run_flow(flow)
def deploy_then_add_flow():
global contract
# For deploy, we initialize the smart contract with the compiled bytecode
contract = SmartContract(bytecode=bytecode)
user.sync_nonce(ElrondProxy(args.proxy))
tx, address = environment.deploy_contract(
contract=contract,
owner=user,
arguments=["0x0064"],
gas_price=config.DEFAULT_GAS_PRICE,
gas_limit=50000000,
value=None,
chain=config.get_chain_id(),
version=config.get_tx_version())
logger.info("Tx hash: %s", tx)
logger.info("Contract address: %s", address.bech32())
# We increment our copy of the nonce
user.nonce += 1
environment.execute_contract(contract=contract,
caller=user,
function="add",
arguments=["0x0064"],
gas_price=config.DEFAULT_GAS_PRICE,
gas_limit=50000000,
value=None,
chain=config.get_chain_id(),
version=config.get_tx_version())
def upgrade_contract(self, contract: SmartContract, caller, arguments,
gas_price, gas_limit, value, chain, version):
logger.debug("upgrade_contract: %s", contract.address.bech32())
tx = contract.upgrade(caller, arguments, gas_price, gas_limit, value,
chain, version)
proxy = self._get_proxy()
tx_hash = tx.send(proxy)
return tx_hash
def deploy_contract(self, contract: SmartContract, owner, arguments,
gas_price, gas_limit, value, chain, version):
logger.debug("deploy_contract")
tx = contract.deploy(owner, arguments, gas_price, gas_limit, value,
chain, version)
proxy = self._get_proxy()
tx_hash = tx.send(proxy)
return tx_hash, contract.address
def deploy_flow():
global contract
# For deploy, we initialize the smart contract with the compiled bytecode
contract = SmartContract(bytecode=bytecode)
tx, address = environment.deploy_contract(contract, owner=bob)
logger.info("Tx hash: %s", tx)
logger.info("Contract address (hex): %s", address.hex())
logger.info("Contract address (bech32): %s", address.bech32())
def _prepare_contract(args: Any) -> SmartContract:
if args.bytecode:
bytecode = utils.read_file(args.bytecode, binary=True).hex()
else:
project = load_project(args.project)
bytecode = project.get_bytecode()
metadata = CodeMetadata(args.metadata_upgradeable, args.metadata_payable)
contract = SmartContract(bytecode=bytecode, metadata=metadata)
return contract
def call(args: Any):
logger.debug("call")
cli_shared.check_broadcast_args(args)
contract_address = args.contract
function = args.function
arguments = args.arguments
gas_price = args.gas_price
gas_limit = args.gas_limit
value = args.value
chain = args.chain
version = args.version
contract = SmartContract(contract_address)
sender = _prepare_sender(args)
tx = contract.execute(sender, function, arguments, gas_price, gas_limit, value, chain, version)
try:
result = _send_or_simulate(tx, args)
finally:
txdict = tx.to_dump_dict()
dump_tx_and_result(txdict, result, args)
def test_compute_address(self):
contract = SmartContract()
contract.owner = Account("93ee6143cdc10ce79f15b2a6c2ad38e9b6021c72a1779051f47154fd54cfbd5e")
contract.owner.nonce = 0
contract.compute_address()
self.assertEqual("00000000000000000500bb652200ed1f994200ab6699462cab4b1af7b11ebd5e", contract.address.hex())
self.assertEqual("erd1qqqqqqqqqqqqqpgqhdjjyq8dr7v5yq9tv6v5vt9tfvd00vg7h40q6779zn", contract.address.bech32())
contract.owner.nonce = 1
contract.compute_address()
self.assertEqual("000000000000000005006e4f90488e27342f9a46e1809452c85ee7186566bd5e", contract.address.hex())
self.assertEqual("erd1qqqqqqqqqqqqqpgqde8eqjywyu6zlxjxuxqfg5kgtmn3setxh40qen8egy", contract.address.bech32())
def query_smart_contract(args):
logger.debug("query_smart_contract")
contract_address = args.contract
proxy_url = args.proxy
function = args.function
arguments = args.arguments
contract = SmartContract(contract_address)
environment = TestnetEnvironment(proxy_url)
def flow():
result = environment.query_contract(contract, function, arguments)
print(result)
environment.run_flow(flow)
def deploy_flow():
global contract
# For deploy, we initialize the smart contract with the compiled bytecode
contract = SmartContract(bytecode=bytecode)
tx, address = environment.deploy_contract(contract=contract,
owner=user,
arguments=["0x0064"],
gas_price=gas_price,
gas_limit=50000000,
value=None,
chain=chain,
version=tx_version)
logger.info("Tx hash: %s", tx)
logger.info("Contract address: %s", address.bech32())
def call_smart_contract(args):
logger.debug("call_smart_contract")
contract_address = args.contract
pem_file = args.pem
proxy_url = args.proxy
function = args.function
arguments = args.arguments
gas_price = args.gas_price
gas_limit = args.gas_limit
value = args.value
contract = SmartContract(contract_address)
environment = TestnetEnvironment(proxy_url)
caller = Account(pem_file=pem_file)
def flow():
tx_hash = environment.execute_contract(contract, caller, function, arguments, gas_price, gas_limit, value)
logger.info("Tx hash: %s", tx_hash)
environment.run_flow(flow)
parser.add_argument("--proxy",
help="testnet Proxy URL",
default=config.get_proxy())
parser.add_argument("--contract", help="existing contract address")
parser.add_argument("--pem", help="PEM file", required=True)
args = parser.parse_args()
logging.basicConfig(level=logging.DEBUG)
# Now, we create a environment which intermediates deployment and execution
proxy = ElrondProxy(args.proxy)
environment = TestnetEnvironment(args.proxy)
user = Account(pem_file=args.pem)
# We initialize the smart contract with an actual address if IF was previously deployed,
contract = SmartContract(address=args.contract,
metadata=CodeMetadata(upgradeable=True))
# A flow defines the desired steps to interact with the contract.
def deploy_flow():
global contract
project = ProjectClang(input("Path to contract project: "))
contract.bytecode = project.get_bytecode()
user.sync_nonce(proxy)
tx, address = environment.deploy_contract(
contract=contract,
owner=user,
arguments=[],
gas_price=config.DEFAULT_GAS_PRICE,
gas_limit=5000000,
def get_delegation_address() -> Address:
contract = SmartContract()
contract.owner = get_owner_of_genesis_contracts()
contract.owner.nonce = 0
contract.compute_address()
return contract.address
def version(shard_id: int, proxy: ElrondProxy) -> str:
dns_address = compute_dns_address_for_shard_id(shard_id)
contract = SmartContract(dns_address)
result = contract.query(proxy, "version", [])
return bytearray.fromhex(result[0].hex).decode()
def validate_name(name: str, shard_id: int, proxy: ElrondProxy):
name_arg = "0x{}".format(str.encode(name).hex())
dns_address = compute_dns_address_for_shard_id(shard_id)
contract = SmartContract(dns_address)
contract.query(proxy, "validateName", [name_arg])
from erdpy.projects import ProjectRust
from erdpy.environments import DebugEnvironment
from erdpy.contracts import SmartContract
from erdpy.accounts import Account
logger = logging.getLogger("examples")
if __name__ == '__main__':
logging.basicConfig(level=logging.DEBUG)
project = ProjectRust("./examples/contracts/myadder")
project.build()
bytecode = project.get_bytecode()
environment = DebugEnvironment()
contract = SmartContract(bytecode=bytecode)
def myflow():
alice = Account(
"aaaaaaaa112233441122334411223344112233441122334411223344aaaaaaaa")
tx, address = environment.deploy_contract(contract,
owner=alice,
arguments=["0x64"])
logger.info("Tx hash: %s", tx)
logger.info("Contract address: %s", address)
querySum()
environment.execute_contract(contract, alice, "add", arguments=["100"])
querySum()
def querySum():
import json
MainMenu, AgencyInfo, ChangeAgency, Wallets, WalletConfiguration, WalletStatus, \
RedelegationPerion, SubscriptionsMenu, availableSpace, availableSpace_threshold, MEXCalc = range(11)
import requests
from erdpy.contracts import SmartContract
from erdpy.accounts import Address
from erdpy.proxy import ElrondProxy
import emoji
mainnet_proxy = ElrondProxy('https://gateway.elrond.com')
TrustStaking_contract = SmartContract('erd1qqqqqqqqqqqqqqqpqqqqqqqqqqqqqqqqqqqqqqqqqqqqqzhllllsp9wvyl')
default_agency = 'trust staking'
db_token = 'mongodb+srv://dragos:[email protected]/telegramBot?retryWrites=true&w=majority'
bot_token = '1654360962:AAFNJTAZxdplj1nrgsv9LnfmCntOMR-DdGg'
main_menu_message = emoji.cat + '''Main menu\n'''
trust_agencies_backup = [
{
'name': "trust staking",
'address': 'erd1qqqqqqqqqqqqqqqpqqqqqqqqqqqqqqqqqqqqqqqqqqqqqzhllllsp9wvyl',
'last_eligible': 0
},
{
'name': "trust staking swiss",
'address': 'erd1qqqqqqqqqqqqqqqpqqqqqqqqqqqqqqqqqqqqqqqqqqqqq08llllsrvplwg',
'last_eligible': 0
},
{
'name': "trust staking us",
def build(self, name):
project = self.load_project(name)
project.build()
bytecode = project.get_bytecode()
contract = SmartContract(bytecode=bytecode)
return project, contract
proxy = ElrondProxy(args.proxy)
network = proxy.get_network_config()
chain = network.chain_id
gas_price = network.min_gas_price
tx_version = network.min_tx_version
environment = TestnetEnvironment(args.proxy)
user = Account(pem_file=args.pem)
project = ProjectRust(Path(__file__).parent.parent)
bytecode = project.get_bytecode()
# We initialize the smart contract with an actual address if IF was previously deployed,
# so that we can start to interact with it ("query_flow")
contract = SmartContract(address=args.contract)
def deploy_flow():
global contract
# For deploy, we initialize the smart contract with the compiled bytecode
contract = SmartContract(bytecode=bytecode)
tx, address = environment.deploy_contract(contract=contract,
owner=user,
arguments=["0x0064"],
gas_price=gas_price,
gas_limit=50000000,
value=None,
chain=chain,
version=tx_version)
# Create a project object afterwards
project = ProjectClang("./examples/contracts/mycounter")
# This will build the smart contract.
# If the buildchain is missing, it will be installed automatically.
project.build()
# We can inspect the bytecode like this:
bytecode = project.get_bytecode()
logger.info("Bytecode: %s", bytecode)
# Now, we create a environment which intermediates deployment and execution
environment = TestnetEnvironment(args.proxy)
bob = Account(pem_file=args.pem)
contract = SmartContract()
# A flow defines the desired steps to interact with the contract.
def deploy_flow():
global contract
# For deploy, we initialize the smart contract with the compiled bytecode
contract = SmartContract(bytecode=bytecode)
tx, address = environment.deploy_contract(contract, owner=bob)
logger.info("Tx hash: %s", tx)
logger.info("Contract address (hex): %s", address.hex())
logger.info("Contract address (bech32): %s", address.bech32())
def query_flow():
global contract
