Market operations¶
Complete examples for understanding and interacting with the Akash marketplace, including bid management, lease operations, and market analytics.
Overview¶
The Akash marketplace connects deployment requests with provider capacity through a bidding system. Understanding market operations helps you optimize costs, ensure deployment success, and monitor marketplace dynamics.
Market Order Process:
graph LR
A[Create Deployment] --> B[Market Orders Created]
B --> C[Providers Submit Bids]Bid Management:
graph LR
D[Evaluate Bids] --> E[Select Best Bid]
E --> F[Create Lease]Lease Lifecycle:
graph LR
G[Monitor Lease] --> H[Track Payments]
H --> I[Settlement & Closure]Market fundamentals¶
API reference
See Market API for orders, bids, leases, and marketplace operations
List market orders¶
from akash import AkashClient, AkashWallet
def list_market_orders(owner_address=None):
"""List current market orders"""
client = AkashClient("https://akash-rpc.polkachu.com:443")
if owner_address:
orders = client.market.get_orders(owner=owner_address)
else:
orders = client.market.get_orders(limit=20)
print(f"Found {len(orders)} market orders")
print("-" * 60)
for order in orders[:10]:
print(f"Order: {order.get('order_id', {}).get('dseq', 'N/A')}")
print(f"Owner: {order.get('order_id', {}).get('owner', 'N/A')}")
print(f"State: {order.get('state', 'unknown')}")
print(f"Spec: {order.get('spec', {})}")
print()
return orders
orders = list_market_orders()
Bid management¶
Monitor incoming bids¶
from akash import AkashClient, AkashWallet
import time
def monitor_deployment_bids(deployment_id, timeout=300):
"""Monitor bids for a specific deployment"""
client = AkashClient("https://akash-rpc.polkachu.com:443")
start_time = time.time()
all_bids = []
print(f"Monitoring bids for deployment {deployment_id['dseq']}")
print("-" * 60)
while time.time() - start_time < timeout:
try:
bids = client.market.get_bids(
owner=deployment_id['owner'],
dseq=deployment_id['dseq']
)
new_bids = []
for bid in bids:
bid_id = f"{bid['bid_id']['provider']}-{bid['bid_id']['dseq']}"
if bid_id not in [b['id'] for b in all_bids]:
new_bids.append({
'id': bid_id,
'bid': bid,
'timestamp': time.time()
})
all_bids.extend(new_bids)
if new_bids:
print(f"\n[{time.strftime('%H:%M:%S')}] New bids received:")
for nb in new_bids:
bid = nb['bid']
print(f"Provider: {bid['bid_id']['provider'][:20]}...")
print(f"Price: {bid['price']['amount']} {bid['price']['denom']}")
print(f"State: {bid['state']}")
open_bids = [b for b in all_bids if b['bid']['state'] == 'open']
if len(open_bids) >= 3:
print(f"\nReceived {len(open_bids)} open bids. Ready to select.")
break
time.sleep(10)
except Exception as e:
print(f"Error checking bids: {e}")
time.sleep(5)
return all_bids
# Example usage with a deployment
# deployment_id = {"owner": "akash1...", "dseq": 12345}
# bids = monitor_deployment_bids(deployment_id)
Evaluate and compare bids¶
from akash import AkashClient, AkashWallet
def evaluate_bids(bids):
"""Evaluate and compare bids based on multiple criteria"""
if not bids:
print("No bids to evaluate")
return None
evaluated_bids = []
for bid in bids:
evaluation = {
'bid': bid,
'price': float(bid['price']['amount']),
'provider': bid['bid_id']['provider'],
'state': bid['state']
}
if 'duration' in bid:
evaluation['price_per_block'] = evaluation['price'] / bid['duration']
evaluated_bids.append(evaluation)
evaluated_bids.sort(key=lambda x: x['price'])
print("Bid evaluation results:")
print("-" * 60)
for i, eval_bid in enumerate(evaluated_bids[:5], 1):
print(f"{i}. Provider: {eval_bid['provider'][:30]}...")
print(f"Price: {eval_bid['price']} uakt")
print(f"State: {eval_bid['state']}")
if 'price_per_block' in eval_bid:
print(f"Price/block: {eval_bid['price_per_block']:.2f}")
print()
return evaluated_bids
# Example with mock bids
mock_bids = [
{'bid_id': {'provider': 'akash1abc...'}, 'price': {'amount': '1000', 'denom': 'uakt'}, 'state': 'open'},
{'bid_id': {'provider': 'akash1def...'}, 'price': {'amount': '1200', 'denom': 'uakt'}, 'state': 'open'},
{'bid_id': {'provider': 'akash1ghi...'}, 'price': {'amount': '900', 'denom': 'uakt'}, 'state': 'open'}
]
evaluated = evaluate_bids(mock_bids)
Accept bid and create lease¶
from akash import AkashClient, AkashWallet
def accept_best_bid(deployment_id, wallet):
"""Accept the best bid and create a lease"""
client = AkashClient("https://akash-rpc.polkachu.com:443")
bids = client.market.get_bids(
owner=deployment_id['owner'],
dseq=deployment_id['dseq']
)
open_bids = [b for b in bids if b['state'] == 'open']
if not open_bids:
print("No open bids available")
return None
evaluated = evaluate_bids(open_bids)
best_bid = evaluated[0]['bid']
print(f"Accepting bid from {best_bid['bid_id']['provider'][:30]}...")
print(f"Price: {best_bid['price']['amount']} {best_bid['price']['denom']}")
result = client.market.create_lease(
wallet=wallet,
owner=best_bid['bid_id']['owner'],
dseq=best_bid['bid_id']['dseq'],
gseq=best_bid['bid_id']['gseq'],
oseq=best_bid['bid_id']['oseq'],
provider=best_bid['bid_id']['provider']
)
if result.success:
print(f"Lease created successfully!")
print(f"Transaction: {result.tx_hash}")
return best_bid['bid_id']
else:
print(f"Failed to create lease: {result.error}")
return None
# Example usage
# deployment_id = {"owner": wallet.address, "dseq": 12345}
# lease_id = accept_best_bid(deployment_id, wallet)
Lease operations¶
List active leases¶
from akash import AkashClient, AkashWallet
def list_active_leases(owner_address=None):
"""List all active leases"""
client = AkashClient("https://akash-rpc.polkachu.com:443")
if owner_address:
leases = client.market.get_leases(owner=owner_address, state="active")
else:
leases = client.market.get_leases(state="active", limit=20)
print(f"Found {len(leases)} active leases")
print("-" * 60)
for lease in leases[:10]:
lease_id = lease.get('lease_id', {})
print(f"Lease: {lease_id.get('dseq', 'N/A')}")
print(f"Owner: {lease_id.get('owner', 'N/A')[:30]}...")
print(f"Provider: {lease_id.get('provider', 'N/A')[:30]}...")
print(f"Price: {lease.get('price', {}).get('amount', 'N/A')} uakt")
print(f"State: {lease.get('state', 'unknown')}")
print()
return leases
active_leases = list_active_leases()
Monitor lease status¶
from akash import AkashClient, AkashWallet
def monitor_lease_status(lease_id, duration=300):
"""Monitor a lease status over time"""
client = AkashClient("https://akash-rpc.polkachu.com:443")
start_time = time.time()
status_history = []
print(f"Monitoring lease {lease_id['dseq']} for {duration}s...")
print("-" * 60)
while time.time() - start_time < duration:
try:
leases = client.market.get_leases(
owner=lease_id['owner'],
dseq=lease_id['dseq'],
gseq=lease_id['gseq'],
oseq=lease_id['oseq'],
provider=lease_id['provider'],
limit=1
)
lease = leases[0] if leases else None
current_status = {
'timestamp': time.time(),
'state': lease.get('state', 'unknown'),
'price': lease.get('price', {}).get('amount', '0'),
'escrow_balance': None
}
if not status_history or status_history[-1]['state'] != current_status['state']:
print(f"\n[{time.strftime('%H:%M:%S')}] Status: {current_status['state']}")
status_history.append(current_status)
if current_status['state'] in ['closed', 'insufficient_funds']:
print(f"Lease ended: {current_status['state']}")
break
time.sleep(30)
except Exception as e:
print(f"Error monitoring lease: {e}")
time.sleep(10)
return status_history
# Example usage
# lease_id = {"owner": "akash1...", "dseq": 12345, "gseq": 1, "oseq": 1, "provider": "akash1..."}
# history = monitor_lease_status(lease_id, 600)
Close lease¶
from akash import AkashClient, AkashWallet
def close_lease(lease_id, wallet):
"""Close an active lease"""
client = AkashClient("https://akash-rpc.polkachu.com:443")
print(f"Closing lease {lease_id['dseq']}...")
result = client.market.close_lease(
wallet=wallet,
owner=lease_id['owner'],
dseq=lease_id['dseq'],
gseq=lease_id['gseq'],
oseq=lease_id['oseq'],
provider=lease_id['provider']
)
if result.success:
print(f"Lease closed successfully!")
print(f"Transaction: {result.tx_hash}")
return True
else:
print(f"Failed to close lease: {result.error}")
return False
# Example usage
# lease_id = {"owner": wallet.address, "dseq": 12345, "gseq": 1, "oseq": 1, "provider": "akash1..."}
# closed = close_lease(lease_id, wallet)
Market analytics¶
Analyze market pricing¶
from akash import AkashClient, AkashWallet
def analyze_market_pricing():
"""Analyze current market pricing trends"""
client = AkashClient("https://akash-rpc.polkachu.com:443")
bids = client.market.get_bids(state="open", limit=100)
if not bids:
print("No bids available for analysis")
return
prices = []
for bid in bids:
try:
price = float(bid['price']['amount'])
prices.append(price)
except (KeyError, ValueError):
continue
if prices:
avg_price = sum(prices) / len(prices)
min_price = min(prices)
max_price = max(prices)
sorted_prices = sorted(prices)
n = len(sorted_prices)
if n % 2 == 0:
median_price = (sorted_prices[n//2-1] + sorted_prices[n//2]) / 2
else:
median_price = sorted_prices[n//2]
print("Market pricing analysis:")
print("-" * 60)
print(f"Total bids analyzed: {len(prices)}")
print(f"Average price: {avg_price:.2f} uakt")
print(f"Median price: {median_price:.2f} uakt")
print(f"Min price: {min_price:.2f} uakt")
print(f"Max price: {max_price:.2f} uakt")
print(f"Price range: {max_price - min_price:.2f} uakt")
print("\nPrice distribution:")
ranges = [(0, 1000), (1000, 5000), (5000, 10000), (10000, float('inf'))]
for low, high in ranges:
count = len([p for p in prices if low <= p < high])
pct = (count / len(prices)) * 100
label = f"{low}-{high}" if high != float('inf') else f"{low}+"
print(f"{label:10} uakt: {count:3} bids ({pct:.1f}%)")
return prices
prices = analyze_market_pricing()
Track market activity¶
from akash import AkashClient, AkashWallet
def track_market_activity(duration=3600):
"""Track market activity over time"""
client = AkashClient("https://akash-rpc.polkachu.com:443")
start_time = time.time()
activity_log = {
'new_orders': [],
'new_bids': [],
'new_leases': [],
'closed_leases': []
}
print(f"Tracking market activity for {duration/60:.0f} minutes...")
print("-" * 60)
initial_orders = set(o['order_id']['dseq'] for o in client.market.get_orders(limit=100))
initial_leases = set(l['lease_id']['dseq'] for l in client.market.get_leases(limit=100))
while time.time() - start_time < duration:
try:
current_orders = client.market.get_orders(limit=100)
for order in current_orders:
dseq = order['order_id']['dseq']
if dseq not in initial_orders:
activity_log['new_orders'].append({
'dseq': dseq,
'timestamp': time.time(),
'owner': order['order_id']['owner'][:20] + '...'
})
initial_orders.add(dseq)
print(f"[{time.strftime('%H:%M:%S')}] New order: {dseq}")
current_leases = client.market.get_leases(limit=100)
for lease in current_leases:
dseq = lease['lease_id']['dseq']
if dseq not in initial_leases:
activity_log['new_leases'].append({
'dseq': dseq,
'timestamp': time.time(),
'provider': lease['lease_id']['provider'][:20] + '...'
})
initial_leases.add(dseq)
print(f"[{time.strftime('%H:%M:%S')}] New lease: {dseq}")
time.sleep(60)
except Exception as e:
print(f"Error tracking activity: {e}")
time.sleep(30)
print("\nActivity summary:")
print(f"New orders: {len(activity_log['new_orders'])}")
print(f"New leases: {len(activity_log['new_leases'])}")
return activity_log
# Example (tracks for 1 hour)
# activity = track_market_activity(3600)
Advanced market strategies¶
Automated bid selection¶
from akash import AkashClient, AkashWallet
def automated_bid_selection(deployment_id, wallet, strategy="lowest_price"):
"""Automatically select and accept bids based on strategy"""
client = AkashClient("https://akash-rpc.polkachu.com:443")
print(f"Using strategy: {strategy}")
print("Waiting for bids...")
max_wait = 300
start_time = time.time()
while time.time() - start_time < max_wait:
bids = client.market.get_bids(
owner=deployment_id['owner'],
dseq=deployment_id['dseq']
)
open_bids = [b for b in bids if b['state'] == 'open']
if len(open_bids) >= 3:
break
time.sleep(10)
if not open_bids:
print("No bids received")
return None
selected_bid = None
if strategy == "lowest_price":
selected_bid = min(open_bids, key=lambda b: float(b['price']['amount']))
elif strategy == "fastest_response":
selected_bid = open_bids[0]
elif strategy == "balanced":
evaluated = evaluate_bids(open_bids)
selected_bid = evaluated[0]['bid'] if evaluated else open_bids[0]
if selected_bid:
print(f"Selected bid: {selected_bid['bid_id']['provider'][:30]}...")
print(f"Price: {selected_bid['price']['amount']} uakt")
result = client.market.create_lease(
wallet=wallet,
owner=selected_bid['bid_id']['owner'],
dseq=selected_bid['bid_id']['dseq'],
gseq=selected_bid['bid_id']['gseq'],
oseq=selected_bid['bid_id']['oseq'],
provider=selected_bid['bid_id']['provider']
)
if result.success:
print(f"Lease created: {result.tx_hash}")
return selected_bid['bid_id']
return None
# Example usage
# deployment_id = {"owner": wallet.address, "dseq": 12345}
# lease = automated_bid_selection(deployment_id, wallet, strategy="balanced")