def publish_asset(metadata, publisher_wallet): ocean = Ocean(config=Config(options_dict=get_config_dict())) # create compute service compute_descriptor = build_compute_descriptor(ocean, publisher_wallet.address) # create asset DDO and datatoken try: asset = ocean.assets.create(metadata, publisher_wallet, [compute_descriptor], dt_name='Dataset with Compute', dt_symbol='DT-Compute') print(f'Dataset asset created successfully: did={asset.did}, datatoken={asset.data_token_address}') except Exception as e: print(f'Publishing asset failed: {e}') return None, None dt = DataToken(asset.data_token_address) txid = dt.mint_tokens(publisher_wallet.address, 100, publisher_wallet) receipt = dt.get_tx_receipt(txid) assert receipt and receipt.status == 1, f'datatoken mint failed: tx={txid}, txReceipt={receipt}' # Create datatoken liquidity pool for the new asset pool = ocean.pool.create(asset.data_token_address, 50, 50, publisher_wallet, 5) print(f'datatoken liquidity pool was created at address {pool.address}') # Now the asset can be discovered and consumed dt_cost = ocean.pool.calcInGivenOut(pool.address, ocean.OCEAN_address, asset.data_token_address, 1.0) print(f'Asset {asset.did} can now be purchased from pool @{pool.address} ' f'at the price of {dt_cost} OCEAN tokens.') return asset, pool
def _deployAndMintToken(symbol: str, to_address: str) -> btoken.BToken: wallet = get_factory_deployer_wallet(_NETWORK) dt_address = DataToken.deploy( wallet.web3, wallet, None, "Template Contract", "TEMPLATE", wallet.address, to_base_18(1000), DTFactory.FIRST_BLOB, to_address, ) dt_factory = DTFactory( DTFactory.deploy(wallet.web3, wallet, None, dt_address, to_address) ) token_address = dt_factory.get_token_address( dt_factory.createToken( symbol, symbol, symbol, DataToken.DEFAULT_CAP_BASE, wallet ) ) token = DataToken(token_address) token.mint(to_address, to_base_18(1000), wallet) return btoken.BToken(token.address)
def buy_data_tokens(self, pool_address: str, amount: float, max_OCEAN_amount: float, from_wallet: Wallet) -> str: """ Buy data tokens from this pool, paying `max_OCEAN_amount_base` of OCEAN tokens. If total spent <= max_OCEAN_amount_base. - Caller is spending OCEAN tokens, and receiving `amount_base` DataTokens - OCEAN tokens are going into pool, DataTokens are going out of pool The transaction fails if total spent exceeds `max_OCEAN_amount_base`. :param pool_address: str address of pool contract :param amount: int number of data tokens to add to this pool in *base* :param max_OCEAN_amount: :param from_wallet: :return: str transaction id/hash """ ocean_tok = DataToken(self.ocean_address) ocean_tok.approve_tokens(pool_address, max_OCEAN_amount, from_wallet, wait=True) dtoken_address = self.get_token_address(pool_address) pool = BPool(pool_address) return pool.swapExactAmountOut( tokenIn_address=self.ocean_address, # entering pool maxAmountIn_base=to_base_18(max_OCEAN_amount), # "" tokenOut_address=dtoken_address, # leaving pool tokenAmountOut_base=to_base_18(amount), # "" maxPrice_base=2**255, # here we limit by max_num_OCEAN, not price from_wallet=from_wallet, )
def buy_at_fixed_rate( self, amount: float, wallet: Wallet, max_OCEAN_amount: float, exchange_id: str = "", data_token: str = "", exchange_owner: str = "", ) -> bool: exchange, exchange_id = self.get_exchange_id_fallback_dt_and_owner( exchange_id, exchange_owner, data_token) amount_base = to_base_18(amount) max_OCEAN_amount_base = to_base_18(max_OCEAN_amount) # Figure out the amount of ocean tokens to approve before triggering the exchange function to do the swap ocean_amount_base = exchange.get_base_token_quote( exchange_id, amount_base) if ocean_amount_base > max_OCEAN_amount_base: raise ValidationError( f"Buying {amount} datatokens requires {from_base_18(ocean_amount_base)} OCEAN " f"tokens which exceeds the max_OCEAN_amount {max_OCEAN_amount}." ) ocean_token = DataToken(self.ocean_address) ocean_token.get_tx_receipt( ocean_token.approve(self._exchange_address, ocean_amount_base, wallet)) tx_id = exchange.buy_data_token(exchange_id, data_token_amount=amount_base, from_wallet=wallet) return bool(exchange.get_tx_receipt(tx_id).status)
def buy_at_fixed_rate(self, amount: float, wallet: Wallet, max_OCEAN_amount: float, exchange_id: str = '', data_token: str = '', exchange_owner: str = '') -> bool: exchange = self._exchange_contract() if not exchange_id: assert exchange_owner and data_token, f'exchange_owner and data_token are required when exchange_id is not given.' exchange_id = exchange.generateExchangeId(self.ocean_address, data_token, exchange_owner) amount_base = to_base_18(amount) max_OCEAN_amount_base = to_base_18(max_OCEAN_amount) # Figure out the amount of ocean tokens to approve before triggering the exchange function to do the swap ocean_amount_base = exchange.get_base_token_quote( exchange_id, amount_base) if ocean_amount_base > max_OCEAN_amount_base: raise AssertionError( f'Buying {amount} datatokens requires {from_base_18(ocean_amount_base)} OCEAN ' f'tokens which exceeds the max_OCEAN_amount {max_OCEAN_amount}.' ) ocean_token = DataToken(self.ocean_address) ocean_token.get_tx_receipt( ocean_token.approve(self._exchange_address, ocean_amount_base, wallet)) tx_id = exchange.buy_data_token(exchange_id, data_token_amount=amount_base, from_wallet=wallet) return bool(exchange.get_tx_receipt(tx_id).status)
def process_order(ocean_instance, publisher_wallet, consumer_wallet, ddo, service_type): """Helper function to process a compute order.""" # Give the consumer some datatokens so they can order the service try: dt = DataToken(ddo.data_token_address) tx_id = dt.transfer_tokens(consumer_wallet.address, 10, publisher_wallet) dt.verify_transfer_tx(tx_id, publisher_wallet.address, consumer_wallet.address) except (AssertionError, Exception) as e: print(e) raise # Order compute service from the dataset asset order_requirements = ocean_instance.assets.order(ddo.did, consumer_wallet.address, service_type=service_type) # Start the order on-chain using the `order` requirements from previous step service = ddo.get_service(service_type) consumer = consumer_wallet.address if service_type == ServiceTypes.ASSET_ACCESS and order_requirements.computeAddress: consumer = order_requirements.computeAddress _order_tx_id = ocean_instance.assets.pay_for_service( order_requirements.amount, order_requirements.data_token_address, ddo.did, service.index, ZERO_ADDRESS, consumer_wallet, consumer, ) return _order_tx_id, order_requirements, service
def publish_asset(metadata, publisher_wallet): ocean = Ocean(config=Config(options_dict=get_config_dict())) # create compute service compute_descriptor = build_compute_descriptor(ocean, publisher_wallet.address) # create asset DDO and datatoken try: asset = ocean.assets.create(metadata, publisher_wallet, [compute_descriptor], dt_name='Compute with data6', dt_symbol='DT-Testx7') print(f'Dataset asset created successfully: did={asset.did}, datatoken={asset.data_token_address}') #Dataset asset created successfully: did=did:op:2cbDb0Aaa1F546829E31267d1a7F74d926Bb5B1B, datatoken=0x2cbDb0Aaa1F546829E31267d1a7F74d926Bb5B1B except Exception as e: print(f'Publishing asset failed: {e}') return None, None dt = DataToken(asset.data_token_address) txid = dt.mint_tokens(publisher_wallet.address, 100, publisher_wallet) receipt = dt.get_tx_receipt(txid) assert receipt and receipt.status == 1, f'datatoken mint failed: tx={txid}, txReceipt={receipt}' # Create datatoken liquidity pool for the new asset pool = ocean.pool.create(asset.data_token_address, 50, 5, publisher_wallet, 5) #50 datatokens - 5 ocean in pool print(f'datatoken liquidity pool was created at address {pool.address}') #datatoken liquidity pool was created at address 0xeaD638506951B4a4c3575bbC0c7D1491c17B7A08 # Now the asset can be discovered and consumed dt_cost = ocean.pool.calcInGivenOut(pool.address, ocean.OCEAN_address, asset.data_token_address, 1.0) print(f'Asset {asset.did} can now be purchased from pool @{pool.address} ' f'at the price of {dt_cost} OCEAN tokens.') return asset, pool
def setup_all(): config = ExampleConfig.get_config() ConfigProvider.set_config(config) Web3Provider.init_web3( provider=get_web3_connection_provider(config.network_url)) ContractHandler.set_artifacts_path(config.artifacts_path) network = Web3Helper.get_network_name() wallet = get_ganache_wallet() if network in ["ganache", "development"] and wallet: print( f"sender: {wallet.key}, {wallet.address}, {wallet.password}, {wallet.keysStr()}" ) print( f"sender balance: {Web3Helper.from_wei(Web3Helper.get_ether_balance(wallet.address))}" ) assert Web3Helper.from_wei(Web3Helper.get_ether_balance( wallet.address)) > 10 from ocean_lib.models.data_token import DataToken OCEAN_token = DataToken(get_ocean_token_address(network)) amt_distribute = 1000 amt_distribute_base = to_base_18(float(amt_distribute)) for w in (get_publisher_wallet(), get_consumer_wallet()): if Web3Helper.from_wei(Web3Helper.get_ether_balance( w.address)) < 2: Web3Helper.send_ether(wallet, w.address, 4) if OCEAN_token.token_balance(w.address) < 100: OCEAN_token.transfer(w.address, amt_distribute_base, from_wallet=wallet)
def is_dispensable(self, dt_address: str, amount: int, to_wallet: Wallet) -> bool: """ :return: bool """ if not amount: return False token = DataToken(self.web3, dt_address) if not self.is_active(dt_address): return False user_balance = token.balanceOf(to_wallet.address) max_balance = self.max_balance(dt_address) if user_balance >= max_balance: return False max_tokens = self.max_balance(dt_address) if amount > max_tokens: return False is_true_minter = self.is_true_minter(dt_address) if is_true_minter: return True contract_balance = self.balance(dt_address) if contract_balance >= amount: return True return False
def cancel_minter(self, dt_address: str, from_wallet: Wallet) -> str: """ :return: hex str transaction hash """ self.send_transaction("removeMinter", (dt_address, ), from_wallet) token = DataToken(self.web3, dt_address) return token.approveMinter(from_wallet)
def get_user_orders( self, address: str, datatoken: Optional[str] = None, service_id: Optional[int] = None, ) -> List[Order]: """ :return: List of orders `[Order]` """ dt = DataToken(self.web3, datatoken) _orders = [] for log in dt.get_start_order_logs( address, from_all_tokens=not bool(datatoken) ): a = dict(log.args.items()) a["amount"] = int(log.args.amount) a["marketFee"] = int(log.args.marketFee) a = AttributeDict(a.items()) # 'datatoken', 'amount', 'timestamp', 'transactionId', 'did', 'payer', 'consumer', 'serviceId', 'serviceType' order = Order( log.address, a.amount, a.timestamp, log.transactionHash, f"did:op:{remove_0x_prefix(log.address)}", a.payer, a.consumer, a.serviceId, None, ) if service_id is None or order.serviceId == service_id: _orders.append(order) return _orders
def get_user_orders(self, address, datatoken=None, service_id=None): dt = DataToken(datatoken) _orders = [] for log in dt.get_start_order_logs( self._web3, address, from_all_tokens=not bool(datatoken)): a = dict(log.args.items()) a["amount"] = from_base_18(int(log.args.amount)) a["marketFee"] = from_base_18(int(log.args.marketFee)) a = AttributeDict(a.items()) # 'datatoken', 'amount', 'timestamp', 'transactionId', 'did', 'payer', 'consumer', 'serviceId', 'serviceType' order = Order( log.address, a.amount, a.timestamp, log.transactionHash, f"did:op:{remove_0x_prefix(log.address)}", a.payer, a.consumer, a.serviceId, None, ) if service_id is None or order.serviceId == service_id: _orders.append(order) return _orders
def make_minter(self, dt_address: str, from_wallet: Wallet) -> str: """ :return: hex str transaction hash """ token = DataToken(self.web3, dt_address) token.proposeMinter(self.address, from_wallet=from_wallet) return self.send_transaction("acceptMinter", (dt_address, ), from_wallet)
def build_and_send_ddo_with_compute_service(client, alg_diff=False, asset_type=None): pub_wallet = get_publisher_wallet() cons_wallet = get_consumer_wallet() # publish an algorithm asset (asset with metadata of type `algorithm`) alg_ddo = (get_algorithm_ddo_different_provider(client, cons_wallet) if alg_diff else get_algorithm_ddo(client, cons_wallet)) alg_data_token = alg_ddo.as_dictionary()["dataToken"] alg_dt_contract = DataToken(alg_data_token) mint_tokens_and_wait(alg_dt_contract, cons_wallet, cons_wallet) # publish a dataset asset if asset_type == "allow_all_published": dataset_ddo_w_compute_service = comp_ds_allow_all_published( client, pub_wallet) elif asset_type == "specific_algo_dids": algos = [] for _ in itertools.repeat(None, 2): alg_ddo = get_algorithm_ddo(client, cons_wallet) alg_data_token = alg_ddo.as_dictionary()["dataToken"] alg_dt_contract = DataToken(alg_data_token) mint_tokens_and_wait(alg_dt_contract, cons_wallet, cons_wallet) algos.append(alg_ddo) dataset_ddo_w_compute_service = comp_ds_specific_algo_dids( client, pub_wallet, algos) else: dataset_ddo_w_compute_service = comp_ds(client, pub_wallet) did = dataset_ddo_w_compute_service.did ddo = dataset_ddo_w_compute_service data_token = dataset_ddo_w_compute_service.data_token_address dt_contract = DataToken(data_token) mint_tokens_and_wait(dt_contract, cons_wallet, pub_wallet) sa = ServiceAgreement.from_ddo(ServiceTypes.CLOUD_COMPUTE, dataset_ddo_w_compute_service) tx_id = send_order(client, ddo, dt_contract, sa, cons_wallet) alg_service = ServiceAgreement.from_ddo(ServiceTypes.ASSET_ACCESS, alg_ddo) alg_tx_id = send_order(client, alg_ddo, alg_dt_contract, alg_service, cons_wallet) return ( dataset_ddo_w_compute_service, did, tx_id, sa, data_token, alg_ddo, alg_data_token, alg_dt_contract, alg_tx_id, )
def test_order(web3, alice_ocean, alice_wallet): asset = get_registered_ddo(alice_ocean, get_metadata(), alice_wallet) dt = DataToken(web3, asset.data_token_address) service = asset.get_service(service_type=ServiceTypes.ASSET_ACCESS) sa = Service.from_json(service.as_dictionary()) order_requirements = alice_ocean.assets.order( asset.did, alice_wallet.address, sa.index ) assert order_requirements, "Order was unsuccessful." _order_tx_id = alice_ocean.assets.pay_for_service( web3, order_requirements.amount, order_requirements.data_token_address, asset.did, service.index, alice_wallet.address, alice_wallet, sa.get_c2d_address(), ) asset_folder = alice_ocean.assets.download( asset.did, sa.index, alice_wallet, _order_tx_id, alice_ocean.config.downloads_path, ) assert len(os.listdir(asset_folder)) >= 1, "The asset folder is empty." for order_log in dt.get_start_order_logs(): order_log_dict = dict(order_log.args.items()) order_log_dict["amount"] = int(order_log.args.amount) order_log_dict["marketFee"] = int(order_log.args.marketFee) order_args = [ order_log.address, order_log_dict["amount"], order_log_dict["timestamp"], order_log.transactionHash, f"did:op:{remove_0x_prefix(order_log.address)}", order_log_dict["payer"], order_log_dict["consumer"], order_log_dict["serviceId"], None, ] order = Order(*order_args) assert order, "The order does not exist." assert isinstance(order, tuple), "Order is not a tuple." assert ( order[0] == asset.data_token_address ), "The order data token address is different." assert order[5] == alice_wallet.address, "The payer is not the supposed one." assert order[6] == sa.get_c2d_address(), "The consumer is not the supposed one." assert len(order) == 9, "Different number of args."
def run_compute(did, consumer_wallet, algorithm_file, pool_address, order_id=None): ocean = Ocean(config=Config(options_dict=get_config_dict())) # Get asset DDO/metadata and service asset = ocean.assets.resolve(did) service = asset.get_service(ServiceTypes.CLOUD_COMPUTE) # check the price in ocean tokens num_ocean = ocean.pool.calcInGivenOut(pool_address, ocean.OCEAN_address, asset.data_token_address, 1.0) # buy datatoken to be able to run the compute service dt = DataToken(asset.asset_id) dt_balance = dt.token_balance(consumer_wallet.address) if dt_balance < 1.0: pool = BPool(pool_address) txid = ocean.pool.buy_data_tokens(pool_address, 1.0, num_ocean+0.1, consumer_wallet) receipt = pool.get_tx_receipt(txid) if not receipt or receipt.status != 1: print(f'buying data token failed: txId={txid}, txReceipt={receipt}') return None, None tx_id = order_id if not tx_id: tx_id = ocean.assets.pay_for_service(1.0, asset.data_token_address, did, service.index, fee_receiver=asset.publisher, from_wallet=consumer_wallet) # load python algorithm to run in the compute job with open(algorithm_file) as f: algorithm_text = f.read() # whether to publish the algorithm results as an Ocean assets output_dict = { 'publishOutput': False, 'publishAlgorithmLog': False, } # start the compute job (submit the compute service request) algorithm_meta = AlgorithmMetadata( { 'language': 'python', 'rawcode': algorithm_text, 'container': { 'tag': 'latest', 'image': 'amancevice/pandas', 'entrypoint': 'python $ALGO' } } ) job_id = ocean.compute.start(did, consumer_wallet, tx_id, algorithm_meta=algorithm_meta, output=output_dict) # check the status of the compute job status = ocean.compute.status(did, job_id, consumer_wallet) print(f'status of compute job {job_id}: {status}') # get the result of the compute run result = ocean.compute.result(did, job_id, consumer_wallet) print(f'got result of compute job {job_id}: {result}') return job_id, status
def test_get_token_minter(web3, alice_wallet, dtfactory_address, alice_address): """Tests proper retrieval of token minter from DTFactory.""" dtfactory = DTFactory(web3, dtfactory_address) dt_address = dtfactory.createToken( "foo_blob", "DT1", "DT1", to_wei(1000), from_wallet=alice_wallet ) dt = DataToken(web3, dtfactory.get_token_address(dt_address)) dt.mint(alice_address, to_wei(10), from_wallet=alice_wallet) assert dtfactory.get_token_minter(dt.address) == alice_address
def validate_order(sender, token_address, num_tokens, tx_id, did, service_id): dt_contract = DataToken(token_address) try: amount = to_base_18(num_tokens) tx, order_event, transfer_event = dt_contract.verify_order_tx( Web3Provider.get_web3(), tx_id, did, service_id, amount, sender) return tx, order_event, transfer_event except AssertionError: raise
def test_data_token_creation(web3, alice_wallet, dtfactory_address): """Tests that a data token can be created using a DTFactory object.""" dtfactory = DTFactory(web3, dtfactory_address) dt_address = dtfactory.createToken( "foo_blob", "DT1", "DT1", to_wei(1000), from_wallet=alice_wallet ) dt = DataToken(web3, dtfactory.get_token_address(dt_address)) assert isinstance(dt, DataToken) assert dt.blob() == "foo_blob" assert dtfactory.verify_data_token(dt.address)
def test1(network, alice_wallet, dtfactory_address): dtfactory = DTFactory(dtfactory_address) dt_address = dtfactory.createToken("foo_blob", "DT1", "DT1", to_base_18(1000), from_wallet=alice_wallet) dt = DataToken(dtfactory.get_token_address(dt_address)) assert isinstance(dt, DataToken) assert dt.blob() == "foo_blob"
def test_compute_specific_algo_dids(client): pub_wallet = get_publisher_wallet() cons_wallet = get_consumer_wallet() # publish a dataset asset dataset_ddo_w_compute_service = get_dataset_ddo_with_compute_service_specific_algo_dids(client, pub_wallet) did = dataset_ddo_w_compute_service.did ddo = dataset_ddo_w_compute_service data_token = dataset_ddo_w_compute_service.as_dictionary()['dataToken'] dt_contract = DataToken(data_token) mint_tokens_and_wait(dt_contract, cons_wallet, pub_wallet) # publish an algorithm asset (asset with metadata of type `algorithm`) alg_ddo = get_algorithm_ddo(client, cons_wallet) alg_data_token = alg_ddo.as_dictionary()['dataToken'] alg_dt_contract = DataToken(alg_data_token) mint_tokens_and_wait(alg_dt_contract, pub_wallet, cons_wallet) # CHECKPOINT 1 sa = ServiceAgreement.from_ddo(ServiceTypes.CLOUD_COMPUTE, dataset_ddo_w_compute_service) tx_id = send_order(client, ddo, dt_contract, sa, cons_wallet) nonce = get_nonce(client, cons_wallet.address) # prepare consumer signature on did msg = f'{cons_wallet.address}{did}{nonce}' _hash = add_ethereum_prefix_and_hash_msg(msg) signature = Web3Helper.sign_hash(_hash, cons_wallet) # Start the compute job payload = dict({ 'signature': signature, 'documentId': did, 'serviceId': sa.index, 'serviceType': sa.type, 'consumerAddress': cons_wallet.address, 'transferTxId': tx_id, 'dataToken': data_token, 'output': build_stage_output_dict(dict(), dataset_ddo_w_compute_service, cons_wallet.address, pub_wallet), 'algorithmDid': alg_ddo.did, 'algorithmMeta': {}, 'algorithmDataToken': alg_data_token }) compute_endpoint = BaseURLs.ASSETS_URL + '/compute' response = client.post( compute_endpoint, data=json.dumps(payload), content_type='application/json' ) assert response.status == '400 BAD REQUEST', f'start compute job failed: {response.status} , { response.data}'
def get_datatoken_info(token_address): token_address = Web3.toChecksumAddress(token_address) dt = DataToken(token_address) contract = dt.contract_concise minter = contract.minter() return { 'address': token_address, 'name': contract.name(), 'symbol': contract.symbol(), 'decimals': contract.decimals(), 'totalSupply': from_base_18(contract.totalSupply()), 'cap': from_base_18(contract.cap()), 'minter': minter, 'minterBalance': dt.token_balance(minter) }
def validate_order(sender, token_address, num_tokens, tx_id, did, service_id): dt_contract = DataToken(token_address) amount = to_base_18(num_tokens) num_tries = 3 i = 0 while i < num_tries: i += 1 try: tx, order_event, transfer_event = dt_contract.verify_order_tx( Web3Provider.get_web3(), tx_id, did, service_id, amount, sender) return tx, order_event, transfer_event except ConnectionClosed: if i == num_tries: raise
def resolve_asset( did: str, metadata_cache_uri: Optional[str] = None, web3: Optional[Web3] = None, token_address: Optional[str] = None, ) -> V3Asset: """Resolve a DID to an URL/DDO or later an internal/external DID. :param did: the asset id to resolve, this is part of the ocean DID did:op:<32 byte value> :param metadata_cache_uri: str the url of the metadata store :param web3: Web3 instance :param token_address: str the address of the DataToken smart contract :return Asset: the resolved DID """ assert metadata_cache_uri or ( web3 and token_address ), "Either metadata_cache_uri or (web3 and token_address) is required." if not metadata_cache_uri: metadata_cache_uri = DataToken(web3, token_address).get_metadata_url() logger.debug(f"found did {did} -> url={metadata_cache_uri}") ddo = AquariusProvider.get_aquarius(metadata_cache_uri).get_asset_ddo(did) if ddo: return V3Asset(dictionary=ddo.as_dictionary())
def get_data_token(self, token_address: str) -> DataToken: """ :param token_address: Token contract address, str :return: `Datatoken` instance """ return DataToken(self.web3, token_address)
def get_datatoken_minter(asset, datatoken_address): publisher = Web3Provider.get_web3().toChecksumAddress(asset.publisher) dt = DataToken(datatoken_address) if not dt.contract_concise.isMinter(publisher): raise AssertionError(f'ddo publisher {publisher} is not the current ' f'minter for the DataToken contract at {datatoken_address}.') return publisher
def test_compute_norawalgo_allowed(client): pub_wallet = get_publisher_wallet() cons_wallet = get_consumer_wallet() # publish a dataset asset dataset_ddo_w_compute_service = get_dataset_ddo_with_compute_service_no_rawalgo(client, pub_wallet) did = dataset_ddo_w_compute_service.did ddo = dataset_ddo_w_compute_service data_token = dataset_ddo_w_compute_service.data_token_address dt_contract = DataToken(data_token) mint_tokens_and_wait(dt_contract, cons_wallet, pub_wallet) # CHECKPOINT 1 algorithm_meta = { "rawcode": "console.log('Hello world'!)", "format": 'docker-image', "version": '0.1', "container": { "entrypoint": 'node $ALGO', "image": 'node', "tag": '10' } } # prepare parameter values for the compute endpoint # signature, documentId, consumerAddress, and algorithmDid or algorithmMeta sa = ServiceAgreement.from_ddo(ServiceTypes.CLOUD_COMPUTE, dataset_ddo_w_compute_service) tx_id = send_order(client, ddo, dt_contract, sa, cons_wallet) nonce = get_nonce(client, cons_wallet.address) # prepare consumer signature on did msg = f'{cons_wallet.address}{did}{nonce}' _hash = add_ethereum_prefix_and_hash_msg(msg) signature = Web3Helper.sign_hash(_hash, cons_wallet) # Start the compute job payload = dict({ 'signature': signature, 'documentId': did, 'serviceId': sa.index, 'serviceType': sa.type, 'consumerAddress': cons_wallet.address, 'transferTxId': tx_id, 'dataToken': data_token, 'output': build_stage_output_dict(dict(), dataset_ddo_w_compute_service, cons_wallet.address, pub_wallet), 'algorithmDid': '', 'algorithmMeta': algorithm_meta, 'algorithmDataToken': '' }) compute_endpoint = BaseURLs.ASSETS_URL + '/compute' response = client.post( compute_endpoint, data=json.dumps(payload), content_type='application/json' ) assert response.status == '400 BAD REQUEST', f'start compute job failed: {response.status} , { response.data}'
def _get_num_assets(_minter): dids = [ add_0x_prefix(did_to_id(a)) for a in ocn.assets.owner_assets(_minter) ] dids = [a for a in dids if len(a) == 42] return len([ a for a in dids if DataToken(a).contract_concise.isMinter(_minter) ])
def test_download_service(client): aqua = Aquarius("http://localhost:5000") try: for did in aqua.list_assets(): aqua.retire_asset_ddo(did) except (ValueError, Exception): pass pub_wallet = get_publisher_wallet() cons_wallet = get_consumer_wallet() ddo = get_dataset_ddo_with_access_service(client, pub_wallet) dt_address = ddo.as_dictionary()["dataToken"] dt_token = DataToken(dt_address) mint_tokens_and_wait(dt_token, cons_wallet, pub_wallet) sa = ServiceAgreement.from_ddo(ServiceTypes.ASSET_ACCESS, ddo) tx_id = send_order(client, ddo, dt_token, sa, cons_wallet) index = 0 download_endpoint = BaseURLs.ASSETS_URL + "/download" # Consume using url index and auth token # (let the provider do the decryption) payload = dict({ "documentId": ddo.did, "serviceId": sa.index, "serviceType": sa.type, "dataToken": dt_address, "consumerAddress": cons_wallet.address, }) payload["signature"] = generate_auth_token(cons_wallet) payload["transferTxId"] = tx_id payload["fileIndex"] = index request_url = (download_endpoint + "?" + "&".join([f"{k}={v}" for k, v in payload.items()])) response = client.get(request_url) assert response.status_code == 200, f"{response.data}" # Consume using url index and signature (withOUT nonce), should fail _hash = add_ethereum_prefix_and_hash_msg(ddo.did) payload["signature"] = Web3Helper.sign_hash(_hash, cons_wallet) request_url = (download_endpoint + "?" + "&".join([f"{k}={v}" for k, v in payload.items()])) print( ">>>> Expecting InvalidSignatureError from the download endpoint <<<<" ) # noqa response = client.get(request_url) assert response.status_code == 400, f"{response.data}" # Consume using url index and signature (with nonce) nonce = get_nonce(client, cons_wallet.address) _hash = add_ethereum_prefix_and_hash_msg(f"{ddo.did}{nonce}") payload["signature"] = Web3Helper.sign_hash(_hash, cons_wallet) request_url = (download_endpoint + "?" + "&".join([f"{k}={v}" for k, v in payload.items()])) response = client.get(request_url) assert response.status_code == 200, f"{response.data}"
def get_token_minter(self, token_address): """Retrieves token minter. This function will be deprecated in the next major release. It's only kept for backwards compatibility.""" from ocean_lib.models.data_token import DataToken # isort:skip dt = DataToken(address=token_address) return dt.contract_concise.minter()