def main(): # create the API api = LedgerApi('127.0.0.1', 8000) # create an entity and provide it some wealth print('Setup...') entity = Entity() api.sync(api.tokens.wealth(entity, 100000000)) print('Setup...complete') # create the contract on the ledger synergetic_contract = Contract(CONTRACT_TEXT) print('Creating contract..') api.sync(api.contracts.create(entity, synergetic_contract, 4096)) print('Contract submitted ({}.{}).'.format( synergetic_contract.digest.to_hex(), synergetic_contract.owner)) # create a whole series of random data to submit to the DAG random_ints = [random.randint(0, 200) for _ in range(10)] api.sync([ api.contracts.submit_data(entity, synergetic_contract.digest, value=value) for value in random_ints ]) print('Data submitted.') print('Waiting...') api.wait_for_blocks(10) print('Issuing query...') result = synergetic_contract.query(api, 'query_result') print('Query result:', result)
def run(options): entity1 = Entity() # create the APIs api = LedgerApi(options['host'], options['port']) api.sync(api.tokens.wealth(entity1, 1000000)) contract = Contract(CONTRACT_TEXT, entity1) contract2 = Contract(CONTRACT_TEXT2, entity1) api.sync(api.contracts.create(entity1, contract, 20000)) api.sync(api.contracts.create(entity1, contract2, 20000)) current_block = api.tokens._current_block_number() api.sync( contract.action(api, 'c2c_call', 40000, [entity1], str(contract2.address))) time.sleep(2) later_block = contract.query(api, 'query_block_number_state') assert later_block > current_block, \ 'Expected number larger than {}, found {}'.format( current_block, later_block)
def create_balance(parameters, test_instance): nodes = parameters["nodes"] amount = parameters["amount"] for node_index in nodes: node_host = "localhost" node_port = test_instance._nodes[node_index]._port_start api = LedgerApi(node_host, node_port) # create the entity from the node's private key entity = Entity(get_nodes_private_key(test_instance, node_index)) tx = api.tokens.transfer(test_instance._benefactor_entity, entity, amount, BASE_TX_FEE) for i in range(10): output('Create balance of: ', amount) api.sync(tx, timeout=120, hold_state_sec=20) for j in range(5): b = api.tokens.balance(entity) output('Current balance: ', b) if b >= amount: return time.sleep(5) time.sleep(5) raise Exception("Failed to send funds to node!")
def prepare_contract(self, price): # Setting API up self._api = LedgerApi('127.0.0.1', 8100) self.scheduler = {} self.price = price self.rate = 22 self.max_count = 10 # Need funds to deploy contract self._api.sync(self._api.tokens.wealth(self._entity, 5000000)) # Create contract self._contract = SmartContract(self._source) # Deploy contract self._api.sync( self._api.contracts.create(self._entity, self._contract, 2456766)) self.chargers = [ Entity(), ] self._contract.action(self._api, 'addCharger', 2456766, [self._entity], Address(self.chargers[0]), int(self.latitude * 1000), int(self.longitude * 1000), self.price, self.rate, self.max_count)
def run_contract(parameters, test_instance): nodes = parameters["nodes"] contract_name = parameters["contract_name"] wait_for_blocks_num = parameters["wait_for_blocks"] for node_index in nodes: node_host = "localhost" node_port = test_instance._nodes[node_index]._port_start api = LedgerApi(node_host, node_port) # create the entity from the node's private key entity = Entity(get_nodes_private_key(test_instance, node_index)) try: contract_helper = test_instance._nodes[node_index]._contract except AttributeError: output( f"No contract stored in test_instance (node_index={node_index})! Loading from file...") contract_helper = SynergeticContractTestHelper( contract_name, api, entity, test_instance._workspace) contract_helper.load() output('Submit data, available balance: ', api.tokens.balance(entity)) contract_helper.submit_random_data(10, (0, 200)) api.wait_for_blocks(wait_for_blocks_num) valid = contract_helper.validate_execution() if not valid: output( f"Synergetic contract ({contract_name}) execution failed on node {node_index}!") raise Exception( f"Synergetic contract ({contract_name}) execution failed on node {node_index}!") else: output( f"Synergetic contract ({contract_name}) executed on node {node_index} ")
def main(): print('Loading private key...') # load up the previously created private key with open('private.key', 'r') as private_key_file: entity1 = Entity.load(private_key_file) print('Loading private key...complete') # build the ledger API api = LedgerApi('127.0.0.1', 8000) # create the smart contract contract = SmartContract(CONTRACT_TEXT) print('Deploying contract...') # deploy the contract to the network api.sync(api.contracts.create(entity1, contract, 2000)) print('Deploying contract...complete') # save the contract to the disk with open('sample.contract', 'w') as contract_file: contract.dump(contract_file)
def run(options, benefactor): entity1 = Entity() api = LedgerApi(options['host'], options['port']) api.sync(api.tokens.transfer(benefactor, entity1, 100000000, 1000)) contract = Contract(CONTRACT_TEXT, entity1) api.sync(api.contracts.create(entity1, contract, 10000)) result = contract.query(api, 'check_x_with_default') assert result == 999,\ 'Expected to receive default value of 999, got {}'.format(result) try: contract.query(api, 'check_x') assert False, 'Expected query to fail' except RuntimeError: pass api.sync(contract.action(api, 'set_x_to_3', 200, entity1)) result = contract.query(api, 'check_x_with_default') assert result == 3, \ 'Expected to receive value of 3, got {}'.format(result) result = contract.query(api, 'check_x') assert result == 3, \ 'Expected to receive value of 3, got {}'.format(result) api.sync(contract.action(api, 'set_x_to_5', 200, entity1)) result = contract.query(api, 'check_x_with_default') assert result == 5, \ 'Expected to receive value of 5, got {}'.format(result) result = contract.query(api, 'check_x') assert result == 5, \ 'Expected to receive value of 5, got {}'.format(result)
def generate_fetchai_wealth(arguments: argparse.Namespace) -> None: """ Generate tokens to be able to make a transaction. :param arguments: the arguments :return: None """ try: api = LedgerApi(arguments.addr, arguments.port) except Exception: logging.info("Couldn't connect! Please check your add and port.") sys.exit(1) try: if arguments.private_key is None or arguments.private_key == "": raise ValueError except ValueError: logging.error("Please provide a private key. --private-key .... ") sys.exit(1) logging.info("Waiting for token wealth generation...") entity_to_generate_wealth = Entity.from_hex( Path(arguments.private_key).read_text()) api.sync(api.tokens.wealth(entity_to_generate_wealth, arguments.amount)) address = Address(entity_to_generate_wealth) balance = api.tokens.balance(address) logging.info('The new balance of the address {} is : {} FET'.format( address, balance))
def __init__(self, network, port): self.network = network self.host = self.get_ip() self.port = port self.api = LedgerApi(self.host, self.port) self.contracts = {} # {'name': ContractInfo} self.entities = {} # {'name' : Entity}
def main(): # load up the previously created private key with open('private.key', 'r') as private_key_file: entity1 = Entity.prompt_load(private_key_file) # load up the deployed contract with open('sample.contract', 'r') as contract_file: contract = Contract.load(contract_file) # for the purposes of this example create a second private key pair to transfer funds to entity2 = Entity() # build the ledger API api = LedgerApi('127.0.0.1', 8000) # print the current status of all the tokens print('-- BEFORE --') print_address_balances(api, contract, [entity1, entity2]) # transfer from one to the other using our newly deployed contract tok_transfer_amount = 200 fet_tx_fee = 40 api.sync( contract.action(api, 'transfer', fet_tx_fee, [entity1], Address(entity1), Address(entity2), tok_transfer_amount)) print('-- AFTER --') print_address_balances(api, contract, [entity1, entity2])
def prepare_contract(self, price): # Setting API up self._api = LedgerApi('127.0.0.1', 8100) self.scheduler = {} self.price = price self.rate = 20 self.max_count = 10 # Need funds to deploy contract self._api.sync(self._api.tokens.wealth(self._entity, 5000000)) # Create contract #self._contract = SmartContract(self._source) # Deploy contract #self._api.sync(self._api.contracts.create(self._entity, self._contract, 2456766)) with open('contract.txt','r') as ff: self.digest = ff.readline().split('\n')[0] self.owner = ff.readline() self.chargers = [Entity(), ] self._api.contracts.action(self.digest, self.owner, 'addCharger', 2456766, [self._entity], Address(self.chargers[0]), self.latitude, self.longitude, self.price, self.rate, self.max_count)
def run(options): entity1 = Entity() # build the ledger API api = LedgerApi(options['host'], options['port']) # create wealth so that we have the funds to be able to create contracts on the network print('Create wealth...') api.sync(api.tokens.wealth(entity1, 100000000)) contract = Contract(CONTRACT_TEXT, entity1) # deploy the contract to the network print('Create contract...') api.sync(api.contracts.create(entity1, contract, 10000)) api.sync(api.tokens.transfer(entity1, contract.address, 10000, 500)) submit_synergetic_data(api, contract, [100, 20, 3], entity1) print('Query init state...') init_result = contract.query(api, 'query_init_test') print('Init state: ', init_result) assert init_result == 123 print('Execute action...') api.sync(contract.action(api, 'action_test', 10000, [entity1])) print('Query action state...') action_result = contract.query(api, 'query_action_test') print('Action state: ', action_result) assert action_result == 456
class InitLedger(OEFAgent): """Class that implements the behaviour of the charger agent.""" def __init__(self, *args, **kwargs): super(InitLedger, self).__init__(*args, **kwargs) self._entity = Entity() self._address = Address(self._entity) with open("../02_full_contract.etch", "r") as fb: self._source = fb.read() self.prepare_contract() def prepare_contract(self): # Setting API up self._api = LedgerApi('127.0.0.1', 8100) # Need funds to deploy contract self._api.sync(self._api.tokens.wealth(self._entity, 5000000)) # Create contract self._contract = SmartContract(self._source) # Deploy contract self._api.sync( self._api.contracts.create(self._entity, self._contract, 2456766)) ff = open('contract.txt', 'w') ff.write(str(self._contract._digest) + "\n") ff.write(str(Address(self._entity))) ff.close()
def releaseEscrew(entity1, contract, entity2): api = LedgerApi(HOST, 8100) fet_tx_fee = 40 api.sync(contract.action(api, 'releaseEscrew', fet_tx_fee, [entity1], entity2, )) print("Escrew Released.")
class TransportAgent(OEFAgent): """Class that implements the behaviour of the scooter agent.""" scooter_description = Description( { "price_per_km": True, }, JOURNEY_MODEL ) def __init__(self, data, *args, **kwargs): super(TransportAgent, self).__init__(*args, **kwargs) self.data = data self._entity = Entity() self._address = Address(self._entity) # with open("./full_contract.etch", "r") as fb: # self._source = fb.read() # self.prepare_contract() def prepare_contract(self): # Setting API up self._api = LedgerApi('185.91.52.11', 10002) # Need funds to deploy contract self._api.sync(self._api.tokens.wealth(self._entity, 5000000)) # Create contract self._contract = SmartContract(self._source) # Deploy contract self._api.sync(self._api.contracts.create(self._entity, self._contract, 2456766)) def on_cfp(self, msg_id: int, dialogue_id: int, origin: str, target: int, query: CFP_TYPES): """Send a simple Propose to the sender of the CFP.""" print("[{0}]: Received CFP from {1}".format(self.public_key, origin)) price = 1 # prepare the proposal with a given price. proposal = Description({"price_per_km": price}) print("[{}]: Sending propose at price: {}".format(self.public_key, price)) self.send_propose(msg_id + 1, dialogue_id, origin, target + 1, [proposal]) def on_accept(self, msg_id: int, dialogue_id: int, origin: str, target: int): """Once we received an Accept, send the requested data.""" print("[{0}]: Received accept from {1}." .format(self.public_key, origin)) # Preparing contract # PLACE HOLDER TO PREPARE AND SIGN TRANSACTION contract = {"contract": "data"} # Sending contract encoded_data = json.dumps(contract).encode("utf-8") print("[{0}]: Sending contract to {1}".format(self.public_key, origin)) self.data['status'] = 'RIDES' self.send_message(0, dialogue_id, origin, encoded_data)
def setEscrew(entity, contract, amount): api = LedgerApi(HOST, 8100) fet_tx_fee = 40 print('-- BEFORE --') print_address_balances(api, contract, [entity]) api.sync(contract.action(api, 'setEscrew', fet_tx_fee, [entity], Address(entity), amount)) print('-- AFTER --') print_address_balances(api, contract, [entity])
def run(options, benefactor): entity1 = Entity() # build the ledger API api = LedgerApi(options['host'], options['port']) # create funds so that we have the funds to be able to create contracts on the network api.sync(api.tokens.transfer(benefactor, entity1, 100000, 1000)) contract = Contract(CONTRACT_TEXT, entity1) # deploy the contract to the network status = api.sync(api.contracts.create(entity1, contract, 2000))[0] api.sync(api.tokens.transfer(entity1, contract.address, 10000, 500)) block_number = status.exit_code v = contract.query(api, 'get_init_block_number_state') assert block_number > 0 assert block_number == v, \ 'Returned block number by the contract ({}) is not what expected ({})'.format( v, block_number) api.sync(contract.action(api, 'set_block_number_state', 400, entity1)) assert block_number <= contract.query(api, 'query_block_number_state')
def wait_for_blocks(self, node_index, number_of_blocks): """ Wait for a specific number of blocks in the selected node :param node_index: which node we are interested in :param number_of_blocks: for how many new block to wait :return: """ port = self._nodes[node_index]._port_start output(f"Waiting for {number_of_blocks} blocks on node {port}") api = LedgerApi("localhost", port) api.wait_for_blocks(number_of_blocks)
def __init__(self, *args, **kwargs): super(RiderAgent, self).__init__(*args, **kwargs) riders = [ '904f302f980617d5f40219337ef826cdf64992e577676cdd83295f189af82ff4', '03f807bbf02cf849145fc51d7dd4438559dc4756a3b2321bbdf42e8f7910a3df', 'dfe06a3baa93ad1d2f248317c601f710821cc1916e09d7c6e261f432563e50f1', 'a92e7c9a1c091bb7bc70874da36fdc44a8217577758a061e008344bd402a6118', '672ebe1ef50a3c49532fe2118686d7025048de51e4f77ed8d0880cd52efe80a7'] self._entity = Entity.from_hex(riders[int(sys.argv[1])-1]) self._address = Address(self._entity) self._api = LedgerApi('127.0.0.1', 8000) self._api.sync(self._api.tokens.wealth(self._entity, 5000000))
def prepare_contract(self): # Setting API up self._api = LedgerApi('185.91.52.11', 10002) # Need funds to deploy contract self._api.sync(self._api.tokens.wealth(self._entity, 5000000)) # Create contract self._contract = SmartContract(self._source) # Deploy contract self._api.sync(self._api.contracts.create(self._entity, self._contract, 2456766))
def prepare_contract(self, price): # Setting API up self._api = LedgerApi('127.0.0.1', 8100) self.longitude = 10 self.latitude = 10 self.scheduler = {} self.price = price self.rate = 22 self.max_count = 10 # Need funds to deploy contract self._api.sync(self._api.tokens.wealth(self._entity, 5000000)) # Create contract self._contract = SmartContract(self._source) # Deploy contract self._api.sync( self._api.contracts.create(self._entity, self._contract, 2456766)) self.chargers = [ Entity(), ] #self._contract.action(self._api, 'test', 2456755, [self._entity], Address(self.chargers[0]), Address(self.chargers[0])) self._contract.action(self._api, 'addCharger', 2456766, [self._entity], Address(self.chargers[0]), self.longitude, self.latitude, self.price, self.rate, self.max_count) scooter = Entity() scooter_start_time = 150000 scooter_end_time = 151000 tx_digest = self._contract.action(self._api, 'book', 2456766, [self._entity], Address(self.chargers[0]), Address(scooter), scooter_start_time, scooter_end_time) time.sleep(3) tx_status = self._api.tx.status(tx_digest) if tx_status == "Executed": self.scheduler[str( Address(scooter))] = [scooter_start_time, scooter_end_time] query = self._contract.query(api=self._api, name='getSlotInfo', charger=Address(self.chargers[0])) print(query)
def create_wealth(parameters, test_instance): nodes = parameters["nodes"] amount = parameters["amount"] for node_index in nodes: node_host = "localhost" node_port = test_instance._nodes[node_index]._port_start api = LedgerApi(node_host, node_port) # create the entity from the node's private key entity = Entity(get_nodes_private_key(test_instance, node_index)) api.sync(api.tokens.wealth(entity, amount))
def releaseEscrew(entity1, contract, entity2): api = LedgerApi(HOST, 8100) fet_tx_fee = 40 api.sync( contract.action( api, 'releaseEscrew', fet_tx_fee, [entity1], Address(entity2), )) print("Escrew Released.") print_address_balances(api, contract, [entity1, entity2])
def main(): # create our first private key pair entity1 = Entity() address1 = Address(entity1) # create a second private key pair entity2 = Entity() address2 = Address(entity2) # build the ledger API api = LedgerApi('127.0.0.1', 8100) # create wealth so that we have the funds to be able to create contracts on the network api.sync(api.tokens.wealth(entity1, 10000)) # create the smart contract contract = SmartContract(CONTRACT_TEXT) # deploy the contract to the network api.sync(api.contracts.create(entity1, contract, 2000)) # print the current status of all the tokens print('-- BEFORE --') print_address_balances(api, contract, [address1, address2]) # transfer from one to the other using our newly deployed contract tok_transfer_amount = 200 fet_tx_fee = 40 api.sync( contract.action(api, 'transfer', fet_tx_fee, [entity1], address1, address2, tok_transfer_amount)) print('-- BEFORE --') print_address_balances(api, contract, [address1, address2])
def main(): entity = Entity.from_hex( '6e8339a0c6d51fc58b4365bf2ce18ff2698d2b8c40bb13fcef7e1ba05df18e4b') address = Address(entity) print('Address:', address) # create the APIs api = LedgerApi(HOST, PORT) # Display balance before print('Balance:', api.tokens.balance(entity)) print('Stake..:', api.tokens.stake(entity)) # submit and wait for the transfer to be complete print('Submitting stake request...') api.sync(api.tokens.add_stake(entity, 1000, 50)) while True: print('Balance............:', api.tokens.balance(entity)) print('Stake..............:', api.tokens.stake(entity)) print('Stake on cooldown..:', api.tokens.stake_cooldown(entity)) # De-stake half of the staked balance to_destake = int(api.tokens.stake(entity) / 2) api.sync(api.tokens.de_stake(entity, to_destake, 500)) # Collect cooled down stakes api.sync(api.tokens.collect_stake(entity, 500)) time.sleep(1)
def test_hostport_or_network(self): """Tests that init accepts only a host+port pair, or a network""" # If providing host or port, must provide both with self.assertRaises(AssertionError): a = LedgerApi(host='host') with self.assertRaises(AssertionError): a = LedgerApi(port=1234) # If providing network, may not provide host or port with self.assertRaises(AssertionError): a = LedgerApi(host='host', network='alpha') with self.assertRaises(AssertionError): a = LedgerApi(port=1234, network='alpha') with self.assertRaises(AssertionError): a = LedgerApi(host='host', port=1234, network='alpha')
def main(): # create the API api = LedgerApi('127.0.0.1', 8000) # create an entity from a private key stored in hex entity = Entity.from_hex( '6e8339a0c6d51fc58b4365bf2ce18ff2698d2b8c40bb13fcef7e1ba05df18e4b') # create the contract on the ledger synergetic_contract = Contract(CONTRACT_TEXT, entity) print('Creating contract..') api.sync(api.contracts.create(entity, synergetic_contract, 4096)) # create a whole series of random data to submit to the DAG random_ints = [random.randint(0, 200) for _ in range(10)] fee = 100000000 api.sync( [api.contracts.submit_data(entity, synergetic_contract.digest, synergetic_contract.address, fee, value=value) \ for value in random_ints]) print('Data submitted.') print('Waiting...') api.wait_for_blocks(10) print('Issuing query...') result = synergetic_contract.query(api, 'query_result') print('Query result:', result)
def deployContract(entity): api = LedgerApi(HOST, 8100) # create the smart contract contract = Contract(CONTRACT_TEXT) print('Deploying contract...') # deploy the contract to the network api.sync(api.contracts.create(entity, contract, 6000)) print('Deploying contract...complete') return contract
def __init__(self, public_key: str, price: int, interval: int, account: Entity, oef_addr: str, oef_port: int = 10000): super().__init__(public_key, oef_addr, oef_port, loop=asyncio.new_event_loop()) self.cost = 0 self.pending_cfp = 0 self.received_proposals = [] self.received_declines = 0 self.interval = interval self.maxPrice = price self.Auction = False self.prevPrice = 0 self.api = LedgerApi('127.0.0.1', 8100) self.account = account
def destake(parameters, test_instance): nodes = parameters["nodes"] for node_index in nodes: node_host = "localhost" node_port = test_instance._nodes[node_index]._port_start # create the API objects we use to interface with the nodes api = LedgerApi(node_host, node_port) # create the entity from the node's private key entity = Entity(get_nodes_private_key(test_instance, node_index)) current_stake = api.tokens.stake(entity) output(f'Destaking node {node_index}. Current stake: ', current_stake) output(f'Destaking node {node_index}. Current balance: ', api.tokens.balance(entity)) api.sync(api.tokens.add_stake(entity, 1, 500)) api.sync(api.tokens.de_stake(entity, current_stake, 500)) api.sync(api.tokens.collect_stake(entity, 500)) output(f'Destaked node {node_index}. Current stake: ', current_stake) output(f'Destaked node {node_index}. Current balance: ', api.tokens.balance(entity)) output(f'Destaked node {node_index}. Current cooldown stake: ', api.tokens.stake_cooldown(entity))