def get_another_consumer_ocean_instance(
use_provider_mock: bool = False) -> Ocean:
data_provider = DataProviderMock if use_provider_mock else None
ocn = Ocean(data_provider=data_provider)
account = get_another_consumer_wallet()
ocn.main_account = account
return ocn
def get_publisher_ocean_instance(use_provider_mock=False) -> Ocean:
config = ExampleConfig.get_config()
data_provider = DataProviderMock if use_provider_mock else None
ocn = Ocean(config, data_provider=data_provider)
account = get_publisher_wallet()
ocn.main_account = account
return ocn
def main(did, pool_address, order_tx_id=None):
ocean = Ocean(config=Config(options_dict=get_config_dict()))
publisher = Wallet(ocean.web3, private_key='0xc594c6e5def4bab63ac29eed19a134c130388f74f019bc74b8f4389df2837a58') # 0xe2DD09d719Da89e5a3D0F2549c7E24566e947260
#consumer = Wallet(ocean.web3, private_key='0x9bf5d7e4978ed5206f760e6daded34d657572bd49fa5b3fe885679329fb16b16') # 0x068Ed00cF0441e4829D9784fCBe7b9e26D4BD8d0
publisher_wallet = Wallet(ocean.web3, private_key=os.getenv('Publisher_Key')) #addr: 0xc966Ba2a41888B6B4c5273323075B98E27B9F364
consumer = Wallet(ocean.web3, private_key=os.getenv('Consumer_Key')) #addr: 0xEF5dc33A53DD2ED3F670B53F07cEc5ADD4D80504
if not (did and pool_address):
metadata_file = './examples/data/metadata.json'
with open(metadata_file) as f:
metadata = json.load(f)
asset, pool = publish_asset(metadata, publisher)
#Dataset asset created successfully: did=did:op:784Cc17176533cc962cf659B9f49349ba6F9df3b, datatoken=0x784Cc17176533cc962cf659B9f49349ba6F9df3b
#pool_address = 0x3490DDd035B2e1DA30Af09AB6090Bf71fdb94898
else:
asset = ocean.assets.resolve(did)
pool = BPool(pool_address)
if not asset:
print(f'publish asset failed, cannot continue with running compute.')
return
print(f'Requesting compute using asset {asset.did} and pool {pool.address}')
algo_file = './examples/data/algorithm.py'
order_tx_id=
job_id, status = run_compute(asset.did, consumer, algo_file, pool.address, order_tx_id)
print(f'Compute started on asset {asset.did}: job_id={job_id}, status={status}')
def make_info(name, private_key_name):
# assume that this account has ETH with gas.
class _Info:
pass
info = _Info()
web3 = get_web3()
config = ExampleConfig.get_config()
info.web3 = web3
info.private_key = os.environ.get(private_key_name)
info.wallet = Wallet(
web3,
private_key=info.private_key,
block_confirmations=config.block_confirmations,
transaction_timeout=config.transaction_timeout,
)
info.address = info.wallet.address
wallet = get_ganache_wallet()
if wallet:
assert get_ether_balance(
web3, wallet.address) >= to_wei(4), "Ether balance less than 4."
if get_ether_balance(web3, info.address) < to_wei(2):
send_ether(wallet, info.address, to_wei(4))
from ocean_lib.ocean.ocean import Ocean
info.ocean = Ocean(config)
info.T1 = _deployAndMintToken(web3, "TOK1", info.address)
info.T2 = _deployAndMintToken(web3, "TOK2", info.address)
return info
def main(did, pool_address, order_tx_id=None):
ocean = Ocean(config=Config(options_dict=get_config_dict()))
publisher = Wallet(
ocean.web3,
private_key="0xc594c6e5def4bab63ac29eed19a134c130388f74f019bc74b8f4389df2837a58",
) # 0xe2DD09d719Da89e5a3D0F2549c7E24566e947260
consumer = Wallet(
ocean.web3,
private_key="0x9bf5d7e4978ed5206f760e6daded34d657572bd49fa5b3fe885679329fb16b16",
) # 0x068Ed00cF0441e4829D9784fCBe7b9e26D4BD8d0
if not (did and pool_address):
metadata_file = "./examples/data/metadata.json"
with open(metadata_file) as f:
metadata = json.load(f)
asset, pool = publish_asset(metadata, publisher)
else:
asset = ocean.assets.resolve(did)
pool = BPool(pool_address)
if not asset:
print("publish asset failed, cannot continue with running compute.")
return
print(f"Requesting compute using asset {asset.did} and pool {pool.address}")
algo_file = "./examples/data/algorithm.py"
job_id, status = run_compute(
asset.did, consumer, algo_file, pool.address, order_tx_id
)
print(f"Compute started on asset {asset.did}: job_id={job_id}, status={status}")
def make_info(name, private_key_name):
# assume that this account has ETH with gas.
class _Info:
pass
info = _Info()
web3 = get_web3()
info.web3 = web3
info.private_key = os.environ.get(private_key_name)
info.wallet = Wallet(web3, private_key=info.private_key)
info.address = info.wallet.address
info.account = Account(private_key=info.private_key)
wallet = get_ganache_wallet()
if wallet:
assert (from_wei(get_ether_balance(wallet.address)) >
4), "Ether balance less than 4."
if from_wei(get_ether_balance(info.address)) < 2:
send_ether(wallet, info.address, 4)
from ocean_lib.ocean.ocean import Ocean
info.ocean = Ocean()
info.T1 = _deployAndMintToken("TOK1", info.address)
info.T2 = _deployAndMintToken("TOK2", info.address)
return info
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 test_metadataStoreUri_version():
config_dict = {
"metadataStoreUri": "http://ItWorked.com",
"network": "rinkeby"
}
ocean_instance = Ocean(config=config_dict)
assert "http://ItWorked.com" == ocean_instance.config.aquarius_url
def initialize_ocean_market():
"""Initialize a test Ocean data market."""
local_config = dotenv_values('../../.env')
os.environ['OCEAN_NETWORK_URL'] = local_config['OCEAN_NETWORK_URL']
config = ExampleConfig.get_config()
ocean = Ocean(config)
return ocean, local_config
def test1():
# ocean instance
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)
ocean = Ocean(config)
OCEAN_address_before = ocean.OCEAN_address
# deploy, distribute, etc
deploy_fake_OCEAN()
# test: OCEAN address should have changed
OCEAN_address_after = ocean.OCEAN_address
assert OCEAN_address_before != OCEAN_address_after
# test: TEST_PRIVATE_KEY{1,2} should each hold OCEAN
wallet1 = Wallet(ocean.web3, private_key=os.getenv("TEST_PRIVATE_KEY1"))
wallet2 = Wallet(ocean.web3, private_key=os.getenv("TEST_PRIVATE_KEY2"))
OCEAN_after = BToken(ocean.OCEAN_address)
assert OCEAN_after.balanceOf(wallet1.address) > 0
assert OCEAN_after.balanceOf(wallet2.address) > 0
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 test_metadataCacheUri_version():
"""Tests that the Aquarius URL can use the custom metadataCacheUri key."""
config_dict = {
"metadataCacheUri": "http://ItWorked.com",
"network": "ganache"
}
ocean_instance = Ocean(config=config_dict)
assert "http://ItWorked.com" == ocean_instance.config.aquarius_url
def test_metadataStoreUri_version():
"""Tests that the Aquarius URL can fallback on the custom metadataStoreUri key."""
config_dict = {
"metadataStoreUri": "http://ItWorked.com",
"network": "rinkeby"
}
ocean_instance = Ocean(config=config_dict)
assert "http://ItWorked.com" == ocean_instance.config.aquarius_url
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_issue185_system(monkeypatch):
"""A system-level test, to replicate original failure seen in #185"""
setup_issue_185(monkeypatch)
# actual test. Imports only come now, to avoid setting class-level attributes
from ocean_lib.ocean.ocean import Ocean
from ocean_lib.web3_internal.wallet import Wallet
private_key = os.getenv("TEST_PRIVATE_KEY1")
config = {"network": os.getenv("NETWORK_URL")}
ocean = Ocean(config)
wallet = Wallet(ocean.web3, private_key=private_key)
# this failed before the fix
datatoken = ocean.create_data_token("Dataset name",
"dtsymbol",
from_wallet=wallet)
assert datatoken is not None
def initialize_market(env_file='env.yaml'):
"""Initialize an Ocean data marketplace.
Args:
env_file (str): An environment variable file,
`env.yaml` by default.
Returns:
"""
config = None
with open(env_file, 'r') as f:
config = yaml.load(f, Loader=yaml.FullLoader)
os.environ['ocean_network_url'] = config['OCEAN_NETWORK_URL']
return Ocean(config)
def initialize(private_key):
load_dotenv(".env")
config = Config(os.getenv('config.ini'))
config = Config(os.getenv('config.ini'))
print(config.network_url)
# config.network_url="https://rinkeby.infura.io/v3/31d95be121a545b688a0e07e4de4d256"
ConfigProvider.set_config(config)
Web3Provider.init_web3(
provider=get_web3_connection_provider(config.network_url))
ContractHandler.set_artifacts_path(config.artifacts_path)
ocean = Ocean()
wallet = Wallet(ocean.web3, private_key=private_key)
return ocean, wallet
def run_scenario():
config = Config('config.ini')
ocean = Ocean(config)
wallet = Wallet(
ocean.web3,
0x376e05899a4ae00463a3a607c774069b7d6a647860dba723f39b735c91238ddf,
None, "EARLYTOBEDANDEARLYTORISE")
ConfigProvider.set_config(config)
Web3Provider.init_web3(
provider=get_web3_connection_provider(config.network_url))
ContractHandler.set_artifacts_path(config.artifacts_path)
print(dir(wallet))
print(wallet.address)
print(config.network_url)
print(config.provider_url)
print(config.network_url)
print(config.artifacts_path)
data_token = ocean.create_data_token('S1Seven', 'S1SV', from_wallet=wallet)
print(f'created new datatoken with address {data_token.address}')
token_address = data_token.address
print(token_address)
'''
def get_user_balances(userAddress):
"""
:param userAddress:
:return:
"""
try:
data = get_request_data(request) or {}
from_block = data.get('fromBlock', int(os.getenv('BFACTORY_BLOCK', 0)))
ocean = Ocean(ConfigProvider.get_config())
result = ocean.pool.get_user_balances(userAddress, from_block)
return Response(json.dumps(result),
200,
content_type='application/json')
except Exception as e:
logger.error(f'pools/user/{userAddress}: {str(e)}')
return f'Get pool user balances failed: {str(e)}', 500
def get_current_liquidity_stats(poolAddress):
"""
:param poolAddress:
:return:
"""
try:
data = get_request_data(request) or {}
dt_address = data.get('datatokenAddress', None)
from_block = data.get('fromBlock', None)
to_block = data.get('toBlock', None)
ocean = Ocean(ConfigProvider.get_config())
pool_info = ocean.pool.get_short_pool_info(poolAddress, dt_address,
from_block, to_block)
return Response(json.dumps(pool_info),
200,
content_type='application/json')
except Exception as e:
logger.error(f'pools/liquidity/{poolAddress}: {str(e)}')
return f'Get pool current liquidity stats failed: {str(e)}', 500
def get_liquidity_history(poolAddress):
"""
:param poolAddress:
:return: json object with two keys: `ocean` and `datatoken`
each has a list of datapoints sampled at specific time intervals from the pools liquidity history.
"""
try:
result = dict()
ocean = Ocean(ConfigProvider.get_config())
pool = BPool(poolAddress)
dt_address = ocean.pool.get_token_address(poolAddress,
pool,
validate=False)
swap_fee = from_base_18(pool.getSwapFee())
ocn_weight = from_base_18(
pool.getDenormalizedWeight(ocean.OCEAN_address))
dt_weight = from_base_18(pool.getDenormalizedWeight(dt_address))
ocn_add_remove_list, dt_add_remove_list = ocean.pool.get_liquidity_history(
poolAddress)
ocn_add_remove_list = [(v, int(t)) for v, t in ocn_add_remove_list]
dt_add_remove_list = [(v, int(t)) for v, t in dt_add_remove_list]
ocn_reserve_history, dt_reserve_history, price_history = build_liquidity_and_price_history(
ocn_add_remove_list, dt_add_remove_list, ocn_weight, dt_weight,
swap_fee)
result['oceanAddRemove'] = ocn_add_remove_list
result['datatokenAddRemove'] = dt_add_remove_list
result['oceanReserveHistory'] = ocn_reserve_history
result['datatokenReserveHistory'] = dt_reserve_history
result['datatokenPriceHistory'] = price_history
return Response(json.dumps(result),
200,
content_type='application/json')
except Exception as e:
logger.error(f'pools/history/{poolAddress}: {str(e)}', exc_info=1)
return f'Get pool liquidity/price history failed: {str(e)}', 500
def test_issue185_unit(monkeypatch):
"""For #185, unit-test the root cause method, which is load"""
setup_issue_185(monkeypatch)
# ensure that conftest::setup_all() was not called
assert ConfigProvider._config is None
assert Web3Provider._web3 is None
assert ContractHandler._contracts == dict()
assert ContractHandler.artifacts_path is None
# actual test. Imports only come now, to avoid setting class-level attributes
# isort: off
from ocean_lib.ocean.ocean import Ocean
from ocean_lib.web3_internal.wallet import Wallet
# isort: on
private_key = os.getenv("TEST_PRIVATE_KEY1")
config = {"network": os.getenv("NETWORK_URL")}
ocean = Ocean(config)
# Ensure it's using a path like '/home/trentmc/ocean.py/venv/artifacts'
assert os.path.exists(ocean._config.artifacts_path)
assert "venv/artifacts" in ocean._config.artifacts_path
wallet = Wallet(ocean.web3, private_key=private_key)
assert wallet is not None
# At this point, shouldn't have any contracts cached
assert ContractHandler._contracts == {}
# This is the call that causes problems in system test.
contract = ContractHandler._get("DataTokenTemplate", None)
assert contract is not None
# The first call may have caused caching. So call again:)
contract = ContractHandler._get("DataTokenTemplate", None)
assert contract is not None
from ocean_lib.models.algorithm_metadata import AlgorithmMetadata
from ocean_lib.models.bpool import BPool
from ocean_lib.models.data_token import DataToken
from ocean_lib.ocean.ocean import Ocean
from ocean_lib.web3_internal.wallet import Wallet
import os
from examples.compute_service import build_compute_descriptor, get_config_dict, run_compute, publish_asset
#Publish Model with compute to data, with training algorithim
#Alice's config
config = {
'network' : os.getenv('NETWORK_URL'),
'metadataStoreUri' : os.getenv('AQUARIUS_URL'),
'providerUri' : os.getenv('PROVIDER_URL'),
}
ocean = Ocean(config)
alice_wallet = Wallet(ocean.web3, private_key=os.getenv('Publisher_Key'))
data_token = ocean.create_data_token('DToxen2', 'DTX2', alice_wallet, blob=ocean.config.metadata_store_url)
token_address = data_token.address
date_created = "2020-02-01T10:55:11Z"
service_attributes = {
"main": {
"name": "dataAssetAccessServiceAgreement",
"creator": alice_wallet.address,
"timeout": 3600 * 24,
"datePublished": date_created,
"cost": 1.0, # <don't change, this is obsolete>
def test_metadataCacheUri_config_key():
"""Tests that the metadata_cache_uri config property can be set using the
`metadataCacheUri` config dict key when created via the Ocean __init__"""
config_dict = {"metadataCacheUri": "http://ItWorked.com", "network": "ganache"}
ocean_instance = Ocean(config=config_dict)
assert "http://ItWorked.com" == ocean_instance.config.metadata_cache_uri
from ocean_lib.ocean.util import get_web3_connection_provider
from ocean_lib.web3_internal.web3_provider import Web3Provider, CustomHTTPProvider
from ocean_lib.data_provider.data_service_provider import DataServiceProvider
from ocean_utils.agreements.service_factory import ServiceDescriptor
from ocean_lib.web3_internal.contract_handler import ContractHandler
from ocean_lib.web3_internal.wallet import Wallet
config = Config('config.ini')
# Ocean instance: create/get datatoken, get dtfactory, user orders (history)
ocean = Ocean(config)
# wallet = Wallet(ocean.web3, b'7n\x05\x89\x9aJ\xe0\x04c\xa3\xa6\x07\xc7t\x06\x9b}jdx`\xdb\xa7#\xf3\x9bs\\\x91#\x8d\xdf', None, "EARLYTOBEDANDEARLYTORISE")
wallet = Wallet(ocean.web3, 0x376e05899a4ae00463a3a607c774069b7d6a647860dba723f39b735c91238ddf, None, "EARLYTOBEDANDEARLYTORISE")
'''
config_file = """
[eth-network]
network = https://rinkeby.infura.io/v3/102d6a75aad644f6a5b131e254d08892
[resources]
aquarius.url = https://aquarius.rinkeby.v3.dev-ocean.com
provider.url = https://provider.rinkeby.v3.dev-ocean.co
"""
'''
import os
from ocean_lib.ocean.ocean import Ocean
from ocean_lib.web3_internal.wallet import Wallet
from ocean_lib.data_provider.data_service_provider import DataServiceProvider
from ocean_utils.agreements.service_factory import ServiceDescriptor
#Publish asset to download. Tetsing
#Alice's config
config = {
'network' : os.getenv('NETWORK_URL'),
'metadataStoreUri' : os.getenv('AQUARIUS_URL'),
'providerUri' : os.getenv('PROVIDER_URL'),
}
ocean = Ocean(config)
alice_wallet = Wallet(ocean.web3, private_key=os.getenv('Publisher_Key'))
data_token = ocean.create_data_token('GPT-2 Pretrained', 'GPT2P', alice_wallet, blob=ocean.config.metadata_store_url)
token_address = data_token.address
date_created = "2020-02-01T10:55:11Z"
service_attributes = {
"main": {
"name": "dataAssetAccessServiceAgreement",
"creator": alice_wallet.address,
"timeout": 3600 * 24,
"datePublished": date_created,
"cost": 1.0, # <don't change, this is obsolete>
}
}
import os
from datetime import date
from ocean_lib.ocean.ocean import Ocean
from ocean_lib.web3_internal.wallet import Wallet
from ocean_lib.data_provider.data_service_provider import DataServiceProvider
from ocean_utils.agreements.service_factory import ServiceDescriptor
import datetime
from ocean_lib.ocean.ocean_compute import OceanCompute
from ocean_lib.ocean.ocean_auth import OceanAuth
import json
ocean = Ocean()
from dotenv import load_dotenv
# from main import initialize
#
from ocean_lib.config import Config
from web3 import Web3
from ocean_lib.config_provider import ConfigProvider
#
# alice_wallet = Wallet(ocean.web3, private_key="58ea0ec8af8f64aad99296c7e7b960ed54c94c8c49a86990a8d369ce9b9a177f")
# trying to make compute jobs in ocean protocol
# we need this auth and all for the compute job
# computer job attributes
def auth_ocean_token(wallet):
ocean_auth = OceanAuth("./storage_tokens")
token = ocean_auth.get(wallet)
return ocean_auth
def main(did, pool_address, order_tx_id=None):
ocean = Ocean(config=Config(options_dict=get_config_dict()))
import os
from ocean_lib.ocean.ocean import Ocean
from ocean_lib.web3_internal.wallet import Wallet
from ocean_lib.config import Config
from ocean_lib.config_provider import ConfigProvider
from ocean_lib.data_provider.data_service_provider import DataServiceProvider
from ocean_utils.agreements.service_factory import ServiceDescriptor
config = Config('config.ini')
ocean = Ocean(config)
alice_wallet = Wallet(ocean.web3, 0x376e05899a4ae00463a3a607c774069b7d6a647860dba723f39b735c91238ddf)
b'Uau3\xc8\x96`\xe5J\xa1\x88x\xeaT\xa6[}\x01kE\xcb\xf4AQ\xdd\xb0\xc2\xb3\xb9Q\xc1\xd5'
web3 = Web
#data_token = ocean.create_data_token('DataToken1', 'DT1', alice_wallet, blob=ocean.config.metadata_store_url)
#data_token = ocean.create_data_token('DataToken1', 'DT1', alice_wallet)
#token_address = data_token.address
import os
from ocean_utils.agreements.service_types import ServiceTypes
from ocean_lib.ocean.ocean import Ocean
from ocean_lib.ocean.util import from_base_18
from ocean_lib.models.bpool import BPool
# Market's config
config = {
'network': os.getenv('NETWORK_URL'),
}
market_ocean = Ocean(config)
#did='did:op:2cbDb0Aaa1F546829E31267d1a7F74d926Bb5B1B' # from step 3
#pool_address = '0xeaD638506951B4a4c3575bbC0c7D1491c17B7A08' # from step 4
asset = market_ocean.assets.resolve(did)
service1 = asset.get_service(ServiceTypes.ASSET_ACCESS)
pool = market_ocean.pool.get(pool_address)
#token_address = '0x2cbDb0Aaa1F546829E31267d1a7F74d926Bb5B1B'
OCEAN_address = market_ocean.pool.ocean_address
price_in_OCEAN = ocean.pool.calcInGivenOut(pool_address,
OCEAN_address,
token_address,
token_out_amount=1.0)
print(f"Price of 1 datatoken is {price_in_OCEAN} OCEAN")
import os
from ocean_lib.ocean.util import to_base_18
from ocean_lib.web3_internal.wallet import Wallet
