def main(): # In examples we use addresses which already have funds entity1 = Entity.from_hex( '6e8339a0c6d51fc58b4365bf2ce18ff2698d2b8c40bb13fcef7e1ba05df18e4b') entity2 = Entity.from_hex( 'e833c747ee0aeae29e6823e7c825d3001638bc30ffe50363f8adf2693c3286f8') address1 = Address(entity1) # create a second private key pair address2 = Address(entity2) # build the ledger API api = LedgerApi('127.0.0.1', 8000) # create the smart contract contract = Contract(CONTRACT_TEXT, entity1) with track_cost(api.tokens, entity1, "Cost of creation: "): api.sync(contract.create(api, entity1, 4000)) # 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 = 160 with track_cost(api.tokens, entity1, "Cost of transfer: "): api.sync( contract.action(api, 'transfer', fet_tx_fee, entity1, address1, address2, tok_transfer_amount)) print('-- AFTER --') print_address_balances(api, contract, [address1, address2])
def main(source, name): # Create keypair for the contract owner provider1 = Entity() address1 = Address(provider1) provider2 = Entity() address2 = Address(provider2) scooter1 = Entity() scooter_address1 = Address(scooter1) # Setting API up api = LedgerApi('127.0.0.1', 8100) # Need funds to deploy contract api.sync(api.tokens.wealth(provider1, 59000000)) # Create contract contract = SmartContract(source) # Deploy contract api.sync(api.contracts.create(provider1, contract, 2456766)) if name.endswith("contract.etch"): contract.action(api, 'addProvider', 2456766, [provider2, provider1], address2, address1) contract.action(api, 'addScooter', 2456766, [provider2, provider1], address2, address1, 22, 1) print("Wait for txs to be mined ...") time.sleep(5) # Printing balance of the creating address1 print(contract.query(api, 'getFleetSize'), " scooter in fleet")
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 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 run(options, benefactor): # Create keypair for the contract owner entity = Entity() address = Address(entity) # build the ledger API api = LedgerApi(options['host'], options['port']) # Need funds to deploy contract api.sync(api.tokens.transfer(benefactor, entity, int(1e7), 1000)) # Load contract source source_file = os.path.join(HERE, "contract.etch") with open(source_file, "r") as fb: source = fb.read() # Create contract contract = Contract(source, entity) # Deploy contract fet_tx_fee = api.tokens.balance(entity) api.sync(api.contracts.create(entity, contract, fet_tx_fee)) # Printing balance of the creating address print(contract.query(api, 'balanceOf', owner=address)) # Getting the 9'th token id. token_id = contract.query(api, 'getTokenId', number=9) # Testing contract.query(api, 'isEqual', number=9, expected=token_id) # Locating the owner of a token print("Finding the owner of ", token_id) print(contract.query(api, 'ownerOf', token_id=token_id))
def run(options, benefactor): # Create keypair for the contract owner entity = Entity() Address(entity) host = options['host'] port = options['port'] # create the APIs api = LedgerApi(host, port) # Transfer tokens from benefactor api.sync(api.tokens.transfer(benefactor, entity, int(1e7), 1000)) # Load contract source source_file = os.path.join(HERE, "hello_world.etch") with open(source_file, "r") as fb: source = fb.read() # Create contract contract = Contract(source, entity) # Deploy contract api.sync(api.contracts.create(entity, contract, 10000)) # Printing message print(contract.query(api, 'persistentGreeting'))
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 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 call(name: str) -> SmartContract: # Create keypair for the contract owner provider1 = Entity() address1 = Address(provider1) # Setting API up api = LedgerApi('185.91.52.11', 10002) # Need funds to deploy contract api.sync(api.tokens.wealth(provider1, 59000000)) with open(name, "r") as fb: source = fb.read() # Create contract contract = SmartContract(source) # Deploy contract api.sync(api.contracts.create(provider1, contract, 2456766)) print("Wait for txs to be mined ...") time.sleep(5) # Printing balance of the creating address1 print(contract.query(api, 'getAccountRides', acc_id="1"))
def main(source, name): # Constellation HOST = '127.0.0.1' PORT = 8100 # deploy the contract to the network api = LedgerApi(HOST, PORT) # api = LedgerApi(network='alphanet') # Create keypair for the contract owner owner = Entity() owner_addr = Address(owner) # print(owner_addr) # Need funds to deploy contract api.sync(api.tokens.wealth(owner, 20000)) # Create contract contract = Contract(source, owner) # Deploy contract api.sync(api.contracts.create(owner, contract, 10000)) # Save the contract to the disk with open('sample.contract', 'w') as contract_file: contract.dump(contract_file) # Save the contract owner's private key to disk with open('owner_private.key', 'w') as private_key_file: owner.dump(private_key_file) print(f"Contract {name}.etch has successfully been deployed.")
def main(source): # Create keypair for the contract owner entity = Entity() address = Address(entity) # Setting API up api = LedgerApi('127.0.0.1', 8100) # Need funds to deploy contract api.sync(api.tokens.wealth(entity, 5000000)) # Create contract contract = SmartContract(source) # Deploy contract api.sync(api.contracts.create(entity, contract, 2456766)) # Printing balance of the creating address print(contract.query(api, 'balanceOf', owner=address)) # Getting the 9'th token id. token_id = contract.query(api, 'getTokenId', number=9) # Testing contract.query(api, 'isEqual', number=9, expected=token_id) # Locating the owner of a token print("Finding the owner of ", token_id) print(contract.query(api, 'ownerOf', token_id=token_id))
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)
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 submitSynergy(entity, values): api = LedgerApi(HOST, 8100) synergy_contract = SynergeticContract(SYNERGYSTIC) print(synergy_contract.digest) api.sync(api.contracts.create(entity, synergy_contract, 4096)) api.sync([api.synergetic.submit_data(entity, synergy_contract.digest, value=value) for value in values]) return synergy_contract
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 main(source, name): # Create keypair for the contract owner charge_provider1 = Entity() charge_address1 = Address(charge_provider1) charge_provider2 = Entity() charge_address2 = Address(charge_provider2) parking_provider1 = Entity() parking_address1 = Address(parking_provider1) parking_provider2 = Entity() parking_address2 = Address(parking_provider2) charge1 = Entity() charge_station_address1 = Address(charge1) parking1 = Entity() parking_place_address1 = Address(parking1) # Setting API up api = LedgerApi('127.0.0.1', 8100) # Need funds to deploy contract api.sync(api.tokens.wealth(charge_provider1, 59000000)) # Create contract contract = SmartContract(source) # Deploy contract api.sync(api.contracts.create(charge_provider1, contract, 2456766)) if name.endswith("contract.etch"): contract.action(api, 'addChargeProvider', 2456766, [charge_provider2, charge_provider1], charge_address2, charge_address1) contract.action(api, 'addCharge', 2456766, [charge_provider2, charge_provider1], charge_address2, charge_address1, 22, 1) print("Wait for charge txs to be mined ...") time.sleep(5) # Printing balance of the creating address1 print(contract.query(api, 'getChargeFleetSize'), " charge in fleet") contract.action(api, 'addParkingProvider', 2456766, [parking_provider2, parking_provider1], parking_address2, parking_address1) contract.action(api, 'addParking', 2456766, [parking_provider2, parking_provider1], parking_address2, parking_address1, 22, 1) print("Wait for parking txs to be mined ...") time.sleep(5) # Printing balance of the creating address1 print(contract.query(api, 'getParkingFleetSize'), " parking in fleet")
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 run(options, benefactor): entity1 = Entity() api = LedgerApi(options['host'], options['port']) api.sync(api.tokens.transfer(benefactor, entity1, 100000, 1000)) contract = Contract(CONTRACT_TEXT, entity1) try: api.sync([contract.action(api, 'some_action', 100, entity1)]) assert False, 'Expected action to fail' except RuntimeError as e: assert 'Contract Lookup Failure' in str(e), \ 'Unexpected error message from server: {}'.format(e)
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 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
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 run(options, benefactor): entity1 = Entity() api = LedgerApi(options['host'], options['port']) api.sync(api.tokens.transfer(benefactor, entity1, 100000, 1000)) contract = Contract(CONTRACT_TEXT, entity1) try: contract.query(api, 'some_query') assert False, 'Expected query to fail' except RuntimeError as e: assert 'Unable to look up contract' in str(e), \ 'Unexpected error message from server: {}'.format(e)
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 run(options): ENDPOINT = 'fetch/token/transfer' HOST = options['host'] PORT = options['port'] # create the APIs api = LedgerApi(HOST, PORT) # Hardcoded private keys id1PrivateKey = "d222867ac019aa7e5b5946ee23100b4437d54ec08db8e89f6e459d497b579a03" id2PrivateKey = "499f40c1bf13e7716e62431b17ab668fa2688b7c94a011a3aab595477bc68347" # Create identities from the private keys id1 = Entity.from_hex(id1PrivateKey) id2 = Entity.from_hex(id2PrivateKey) # Load 1000 tokens to id1 api.sync(api.tokens.wealth(id1, 1000)) # signed transaction that transfers 250 FET from id1 to id2. Signed with (r,s) orig_tx = 'a1440000c5ab20e3ab845cb4a1d2c3e4c3b08f5ff42a6ff2a71d7697ba8f32c415b77c7f8d850b3ef025b189a2d9bb4a515a84c3673db6d3ef25385d2c8d1e34b06e2de1c0fac08501140000000000000000040bafbc61a08524372f495d9dee08adbc39824e980506947091395cece16636ddc094b9d409d5b34ef0bbd9c99c5caf21fc373802472cf96a8a280f84e833f992402192a0a125d551b60800d441cb3483cd36573c22a73f22563d6dd7b27e677b98ba4e2f77596888839a3c6f2439c97949ea28923f168d360a6d155c2be79570af' # signed Malicious transaction of the previous transaction. Signed with (r,n-s) mal_tx = 'a1440000c5ab20e3ab845cb4a1d2c3e4c3b08f5ff42a6ff2a71d7697ba8f32c415b77c7f8d850b3ef025b189a2d9bb4a515a84c3673db6d3ef25385d2c8d1e34b06e2de1c0fac08501140000000000000000040bafbc61a08524372f495d9dee08adbc39824e980506947091395cece16636ddc094b9d409d5b34ef0bbd9c99c5caf21fc373802472cf96a8a280f84e833f99240f1a0311cc9b42edaa41d537e3d1f9d54ac159504276c27be2973cea85c8e8a17148a2b1dc3e188f911c6b05f163d95b964ae594a347870973e59b3c93d35b895' # Creating jsons for the above mentioned transactions legit_trans = submit_json_transaction( host=HOST, port=PORT, tx_data=dict(ver="1.2", data=base64.b64encode( binascii.unhexlify(orig_tx)).decode()), endpoint=ENDPOINT) mal_trans = submit_json_transaction( host=HOST, port=PORT, tx_data=dict(ver="1.2", data=base64.b64encode( binascii.unhexlify(mal_tx)).decode()), endpoint=ENDPOINT) # Sending the transactions to the ledger assert legit_trans == mal_trans, "Malleable transactions have different transaction hash" api.sync([legit_trans, mal_trans]) # If transaction malleability is feasible, id2 should have 500 FET. # If balance of id2 is more than 250 raise an exception assert api.tokens.balance( id2) == 250, "Vulnerable to transaction malleability attack"
def run(options, benefactor): ENDPOINT = 'fetch/token/transfer' HOST = options['host'] PORT = options['port'] # create the APIs api = LedgerApi(HOST, PORT) # Hardcoded private keys id1PrivateKey = "d222867ac019aa7e5b5946ee23100b4437d54ec08db8e89f6e459d497b579a03" id2PrivateKey = "499f40c1bf13e7716e62431b17ab668fa2688b7c94a011a3aab595477bc68347" # Create identities from the private keys id1 = Entity.from_hex(id1PrivateKey) id2 = Entity.from_hex(id2PrivateKey) # Load 100000 tokens to id1 api.sync(api.tokens.transfer(benefactor, id1, 100000, 1000)) # signed transaction that transfers 2500 FET from id1 to id2. Signed with (r,s) Fees are 1000 orig_tx = 'a1640000c5ab20e3ab845cb4a1d2c3e4c3b08f5ff42a6ff2a71d7697ba8f32c415b77c7f8d850b3ef025b189a2d9bb4a515a84c3673db6d3ef25385d2c8d1e34b06e2de1c109c46501c103e8565596cd793442c5040bafbc61a08524372f495d9dee08adbc39824e980506947091395cece16636ddc094b9d409d5b34ef0bbd9c99c5caf21fc373802472cf96a8a280f84e833f99240f1c72a58927153d6fdc19f178f69c5b02db29f33541e2b946c78a54ce693c7c81082f22531b85a1707cf290f73fddd2df88681084b0cc7aff38e977215ae5899' # signed Malicious transaction of the previous transaction. Signed with (r,n-s) mal_tx = 'a1640000c5ab20e3ab845cb4a1d2c3e4c3b08f5ff42a6ff2a71d7697ba8f32c415b77c7f8d850b3ef025b189a2d9bb4a515a84c3673db6d3ef25385d2c8d1e34b06e2de1c109c46501c103e8565596cd793442c5040bafbc61a08524372f495d9dee08adbc39824e980506947091395cece16636ddc094b9d409d5b34ef0bbd9c99c5caf21fc373802472cf96a8a280f84e833f99240cb13a3a05600cd45c7abe860515801941d6eef439e697ab31015543b515e5b85495f2a3f95a352747eda205cc70e0bca7a4d8b1240dfbd43f3a047a1faad30bd' # Creating jsons for the above mentioned transactions legit_trans = submit_json_transaction( host=HOST, port=PORT, tx_data=dict(ver="1.2", data=base64.b64encode( binascii.unhexlify(orig_tx)).decode()), endpoint=ENDPOINT) mal_trans = submit_json_transaction( host=HOST, port=PORT, tx_data=dict(ver="1.2", data=base64.b64encode( binascii.unhexlify(mal_tx)).decode()), endpoint=ENDPOINT) # Sending the transactions to the ledger assert legit_trans == mal_trans, "Malleable transactions have different transaction hash" api.sync([legit_trans, mal_trans]) # If transaction malleability is feasible, id2 should have 500 FET. # If balance of id2 is more than 250 raise an exception assert api.tokens.balance( id2) == 2500, "Vulnerable to transaction malleability attack"
def main(): # create the APIs api = LedgerApi(HOST, PORT) # generate identities from hex private keys, identity1 = Entity.from_hex('6e8339a0c6d51fc58b4365bf2ce18ff2698d2b8c40bb13fcef7e1ba05df18e4b') identity2 = Entity.from_hex('e833c747ee0aeae29e6823e7c825d3001638bc30ffe50363f8adf2693c3286f8') print('Balance 1 Before:', api.tokens.balance(identity1)) print('Balance 2 Before:', api.tokens.balance(identity2)) # submit and wait for the transfer to be complete print('Submitting transfer...') api.sync(api.tokens.transfer(identity1, identity2, 250, 20)) print('Balance 1:', api.tokens.balance(identity1)) print('Balance 2:', api.tokens.balance(identity2))
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')