Market¶

The Market module handles the decentralized marketplace where deployment orders are matched with provider bids to create leases for compute resources.

Transaction parameters

All transaction functions support flexible parameters. See Transaction parameters for details on available options like fee_amount, gas_limit, and gas_adjustment.

MarketClient class¶

from akash import AkashClient

client = AkashClient("https://akash-rpc.polkachu.com:443")

market = client.market

Transactions¶

create_bid()¶

Creates a bid on a deployment order.

def create_bid(wallet, owner: str, dseq: int, gseq: int = 1, oseq: int = 1, 
               price: str = "100", deposit: str = "5000000", denom: str = "uakt", 
               memo: str = "", fee_amount: str = None, gas_limit: int = None, 
               gas_adjustment: float = 1.2, use_simulation: bool = True) -> BroadcastResult

Required parameters:

wallet (Wallet): Provider wallet instance (must be provider)
owner (str): Deployment owner address
dseq (int): Deployment sequence number

Optional parameters:

gseq (int): Group sequence number (default: 1)
oseq (int): Order sequence number (default: 1)
price (str): Bid price per unit (default: "100")
deposit (str): Deposit amount (default: "5000000")
denom (str): Price denomination (default: "uakt")
memo (str): Transaction memo (default: "")
fee_amount (str): Transaction fee amount (default: auto-calculated)
gas_limit (int): Gas limit (default: auto-estimated)
gas_adjustment (float): Gas estimation multiplier (default: 1.2)
use_simulation (bool): Enable gas simulation (default: True)

Returns: BroadcastResult with the following fields:

tx_hash (str): Transaction hash
code (int): Response code (0 for success)
raw_log (str): Raw transaction log/error message
success (bool): Whether transaction succeeded
events (List[Dict]): Transaction events
- type (str): Event type
- attributes (List[Dict]): Event attributes
  - key (str): Attribute key
  - value (str): Attribute value

Example:

from akash import AkashClient, AkashWallet

client = AkashClient("https://akash-rpc.polkachu.com:443")
wallet = AkashWallet.from_mnemonic("provider mnemonic here")

result = client.market.create_bid(
    wallet=wallet,
    owner="akash1...",
    dseq=12345,
    price="150",
    deposit="5000000"
)

if result.success:
    print(f"Bid created: {result.tx_hash}")
else:
    print(f"Bid failed: {result.log}")

close_bid()¶

Closes an existing bid.

def close_bid(wallet, owner: str, dseq: int, gseq: int = 1, oseq: int = 1, 
              provider: str = None, memo: str = "", fee_amount: str = None, 
              gas_limit: int = None, gas_adjustment: float = 1.2, 
              use_simulation: bool = True) -> BroadcastResult

Required parameters:

wallet (Wallet): Provider wallet instance
owner (str): Deployment owner address
dseq (int): Deployment sequence number

Optional parameters:

gseq (int): Group sequence number (default: 1)
oseq (int): Order sequence number (default: 1)
provider (str): Provider address (default: wallet address)
memo (str): Transaction memo
fee_amount (str): Transaction fee amount
gas_limit (int): Gas limit
gas_adjustment (float): Gas estimation multiplier
use_simulation (bool): Enable gas simulation

Returns: BroadcastResult with the following fields:

tx_hash (str): Transaction hash
code (int): Response code (0 for success)
raw_log (str): Raw transaction log/error message
success (bool): Whether transaction succeeded
events (List[Dict]): Transaction events
- type (str): Event type
- attributes (List[Dict]): Event attributes
  - key (str): Attribute key
  - value (str): Attribute value

Example:

from akash import AkashClient, AkashWallet

client = AkashClient("https://akash-rpc.polkachu.com:443")
wallet = AkashWallet.from_mnemonic("provider mnemonic here")

result = client.market.close_bid(
    wallet=wallet,
    owner="akash1...",
    dseq=12345
)

create_lease()¶

Creates a lease from an accepted bid.

def create_lease(wallet, owner: str, dseq: int, gseq: int = 1, oseq: int = 1, 
                 provider: str = None, memo: str = "", fee_amount: str = None, 
                 gas_limit: int = None, gas_adjustment: float = 1.2, 
                 use_simulation: bool = True) -> BroadcastResult

Required parameters:

wallet (Wallet): Deployment owner wallet instance
owner (str): Deployment owner address
dseq (int): Deployment sequence number

Optional parameters:

gseq (int): Group sequence number (default: 1)
oseq (int): Order sequence number (default: 1)
provider (str): Provider address
memo (str): Transaction memo
fee_amount (str): Transaction fee amount
gas_limit (int): Gas limit
gas_adjustment (float): Gas estimation multiplier
use_simulation (bool): Enable gas simulation

Returns: BroadcastResult with the following fields:

tx_hash (str): Transaction hash
code (int): Response code (0 for success)
raw_log (str): Raw transaction log/error message
success (bool): Whether transaction succeeded
events (List[Dict]): Transaction events
- type (str): Event type
- attributes (List[Dict]): Event attributes
  - key (str): Attribute key
  - value (str): Attribute value

Example:

from akash import AkashClient, AkashWallet

client = AkashClient("https://akash-rpc.polkachu.com:443")
wallet = AkashWallet.from_mnemonic("owner mnemonic here")

result = client.market.create_lease(
    wallet=wallet,
    owner=wallet.address,
    dseq=12345,
    provider="akash1provider..."
)

close_lease()¶

Closes an active lease.

def close_lease(wallet, owner: str, dseq: int, gseq: int = 1, oseq: int = 1, 
                provider: str = None, memo: str = "", fee_amount: str = None, 
                gas_limit: int = None, gas_adjustment: float = 1.2, 
                use_simulation: bool = True) -> BroadcastResult

Required parameters:

wallet (Wallet): Owner or provider wallet instance
owner (str): Deployment owner address
dseq (int): Deployment sequence number

Optional parameters:

gseq (int): Group sequence number (default: 1)
oseq (int): Order sequence number (default: 1)
provider (str): Provider address
memo (str): Transaction memo
fee_amount (str): Transaction fee amount
gas_limit (int): Gas limit
gas_adjustment (float): Gas estimation multiplier
use_simulation (bool): Enable gas simulation

Returns: BroadcastResult with the following fields:

tx_hash (str): Transaction hash
code (int): Response code (0 for success)
raw_log (str): Raw transaction log/error message
success (bool): Whether transaction succeeded
events (List[Dict]): Transaction events
- type (str): Event type
- attributes (List[Dict]): Event attributes
  - key (str): Attribute key
  - value (str): Attribute value

Example:

from akash import AkashClient, AkashWallet

client = AkashClient("https://akash-rpc.polkachu.com:443")
wallet = AkashWallet.from_mnemonic("owner mnemonic here")

result = client.market.close_lease(
    wallet=wallet,
    owner=wallet.address,
    dseq=12345,
    provider="akash1provider..."
)

if result.success:
    print(f"Lease closed: {result.tx_hash}")
else:
    print(f"Close failed: {result.raw_log}")

withdraw_lease()¶

Withdraws funds from closed lease escrow.

def withdraw_lease(wallet, owner: str, dseq: int, gseq: int = 1, oseq: int = 1, 
                   provider: str = None, memo: str = "", fee_amount: str = None, 
                   gas_limit: int = None, gas_adjustment: float = 1.2, 
                   use_simulation: bool = True) -> BroadcastResult

Required parameters:

wallet (Wallet): Deployment owner wallet instance
owner (str): Deployment owner address
dseq (int): Deployment sequence number

Optional parameters:

gseq (int): Group sequence number (default: 1)
oseq (int): Order sequence number (default: 1)
provider (str): Provider address
memo (str): Transaction memo
fee_amount (str): Transaction fee amount
gas_limit (int): Gas limit
gas_adjustment (float): Gas estimation multiplier
use_simulation (bool): Enable gas simulation

Returns: BroadcastResult with the following fields:

tx_hash (str): Transaction hash
code (int): Response code (0 for success)
raw_log (str): Raw transaction log/error message
success (bool): Whether transaction succeeded
events (List[Dict]): Transaction events
- type (str): Event type
- attributes (List[Dict]): Event attributes
  - key (str): Attribute key
  - value (str): Attribute value

Example:

from akash import AkashClient, AkashWallet

client = AkashClient("https://akash-rpc.polkachu.com:443")
wallet = AkashWallet.from_mnemonic("owner mnemonic here")

result = client.market.withdraw_lease(
    wallet=wallet,
    owner=wallet.address,
    dseq=12345,
    provider="akash1provider..."
)

if result.success:
    print(f"Funds withdrawn: {result.tx_hash}")
else:
    print(f"Withdrawal failed: {result.raw_log}")

Queries¶

get_orders()¶

Retrieves deployment orders available for bidding.

def get_orders(owner: str = None, state: str = None, dseq: int = None, 
               gseq: int = None, oseq: int = None, limit: int = None, 
               offset: int = None, count_total: bool = False) -> List[Dict[str, Any]]

Optional parameters:

owner (str): Filter by deployment owner address
state (str): Filter by order state ("open", "active", "closed")
dseq (int): Filter by deployment sequence number
gseq (int): Filter by group sequence number
oseq (int): Filter by order sequence number
limit (int): Maximum number of results to return
offset (int): Number of results to skip
count_total (bool): Include total count in response (default: False)

Returns: List[Dict] - List of order information dictionaries with the following fields:

order_id (Dict): Order identifier
- owner (str): Order owner address
- dseq (int): Deployment sequence number
- gseq (int): Group sequence number
- oseq (int): Order sequence number
state (int): Order state (1=open, 2=matched, 3=closed)
spec (Dict): Order specification
- name (str): Service name
- image (str): Container image
- command (List[str]): Command override
- args (List[str]): Arguments
- env (List[str]): Environment variables
- expose (List[Dict]): Port exposures
  - port (int): Container port
  - as (int): External port
  - accept (List[str]): Accepted hostnames
  - to (List[Dict]): Traffic routing
    - service (str): Target service name
- resources (Dict): Resource requirements
  - cpu (Dict): CPU requirements
    - units (str): CPU units
  - memory (Dict): Memory requirements
    - quantity (str): Memory quantity
  - storage (List[Dict]): Storage requirements
    - quantity (str): Storage quantity
created_at (int): Order creation timestamp

Example:

from akash import AkashClient

client = AkashClient("https://akash-rpc.polkachu.com:443")

open_orders = client.market.get_orders(state="open", limit=10)
deployment_orders = client.market.get_orders(owner="akash1...", dseq=12345)
paged_orders = client.market.get_orders(limit=20, offset=40)

for order in open_orders:
    order_id = order['order_id']
    print(f"Order {order_id['dseq']}.{order_id['gseq']}.{order_id['oseq']} by {order_id['owner']}")
    resources = order['spec']['resources']
    print(f"CPU: {resources['cpu']['units']}, Memory: {resources['memory']['quantity']}")

get_bids()¶

Retrieves bids submitted by providers.

def get_bids(provider: str = None, owner: str = None, state: str = None, 
             dseq: int = None, gseq: int = None, oseq: int = None, 
             limit: int = None, offset: int = None, count_total: bool = False) -> List[Dict[str, Any]]

Optional parameters:

provider (str): Filter by provider address
owner (str): Filter by deployment owner
state (str): Filter by bid state ("open", "active", "lost", "closed")
dseq (int): Filter by deployment sequence number
gseq (int): Filter by group sequence number
oseq (int): Filter by order sequence number
limit (int): Maximum number of results
offset (int): Number of results to skip
count_total (bool): Include total count

Returns: List[Dict] - List of bid information with the following fields:

bid_id (Dict): Bid identifier
- owner (str): Deployment owner address
- dseq (int): Deployment sequence number
- gseq (int): Group sequence number
- oseq (int): Order sequence number
- provider (str): Provider address
state (int): Bid state (1=open, 2=active, 3=lost, 4=closed)
price (Dict): Bid price information
- denom (str): Price denomination
- amount (str): Price amount per block
created_at (int): Block height when bid was created
escrow_account (Dict): Escrow account information
- balance (str): Escrow balance
- state (int): Escrow account state

Example:

from akash import AkashClient

client = AkashClient("https://akash-rpc.polkachu.com:443")

open_bids = client.market.get_bids(state="open", limit=10)
active_bids = client.market.get_bids(state="active", limit=10)
provider_bids = client.market.get_bids(provider="akash1provider...")
deployment_bids = client.market.get_bids(owner="akash1...", dseq=12345)

state_names = {1: "open", 2: "active", 3: "lost", 4: "closed"}

for bid in open_bids:
    price_akt = int(bid['price']['amount']) / 1_000_000
    provider = bid['bid_id']['provider'][:15] + "..."
    state_name = state_names.get(bid['state'], f"unknown({bid['state']})")
    print(f"Provider {provider}: {price_akt:.6f} AKT/block")
    print(f"DSEQ: {bid['bid_id']['dseq']}, State: {state_name}")

get_leases()¶

Retrieves leases using proper ABCI query.

def get_leases(provider: str = None, owner: str = None, state: str = None, 
               dseq: int = None, gseq: int = None, oseq: int = None, 
               limit: int = None, offset: int = None, count_total: bool = False) -> List[Dict[str, Any]]

Optional parameters:

provider (str): Filter by provider address
owner (str): Filter by deployment owner
state (str): Filter by lease state ("active", "insufficient_funds", "closed")
dseq (int): Filter by deployment sequence number
gseq (int): Filter by group sequence number
oseq (int): Filter by order sequence number
limit (int): Maximum number of results
offset (int): Number of results to skip
count_total (bool): Include total count

Returns: List[Dict] - List of lease information with the following fields:

lease_id (Dict): Lease identifier
- owner (str): Deployment owner address
- dseq (int): Deployment sequence number
- gseq (int): Group sequence number
- oseq (int): Order sequence number
- provider (str): Provider address
state (str): Lease state ("active", "insufficient_funds", "closed")
price (Dict): Lease price information
- denom (str): Price denomination
- amount (str): Price amount per block
created_at (int): Block height when lease was created
closed_on (int): Block height when lease was closed (if closed)
escrow_payment (Dict, optional): Escrow payment information (may be None)
- balance (str): Escrow balance amount
- state (int): Escrow payment state
- withdrawn (str): Amount withdrawn

Example:

from akash import AkashClient

client = AkashClient("https://akash-rpc.polkachu.com:443")

active_leases = client.market.get_leases(state="active", limit=10)
insufficient_leases = client.market.get_leases(state="insufficient_funds")
my_provider_leases = client.market.get_leases(provider="akash1...", limit=20)
my_owner_leases = client.market.get_leases(owner="akash1...", limit=20)
deployment_leases = client.market.get_leases(owner="akash1...", dseq=12345)

for lease in active_leases:
    lease_id = lease['lease_id']
    price_akt = int(lease['price']['amount']) / 1_000_000
    print(f"Lease {lease_id['dseq']}.{lease_id['gseq']}.{lease_id['oseq']}")
    print(f"Provider: {lease_id['provider']}")
    print(f"Price: {price_akt:.6f} AKT per block")

    if 'escrow_payment' in lease and lease['escrow_payment']:
        balance_akt = int(lease['escrow_payment']['balance']) / 1_000_000
        print(f"Escrow balance: {balance_akt:.6f} AKT")

get_order()¶

Get a specific order by ID.

def get_order(owner: str, dseq: int, gseq: int = 1, oseq: int = 1) -> Optional[Dict[str, Any]]

Required parameters:

owner (str): Deployment owner address
dseq (int): Deployment sequence number

Optional parameters:

gseq (int): Group sequence number (default: 1)
oseq (int): Order sequence number (default: 1)

Returns: Optional[Dict] - Order information or None if not found:

order_id (Dict): Order identifier
- owner (str): Deployment owner address
- dseq (int): Deployment sequence number
- gseq (int): Group sequence number
- oseq (int): Order sequence number
state (int): Order state (1=open, 2=active, 3=closed)
spec (Dict): Order specification
- name (str): Service name
- image (str): Container image
- command (List[str]): Container command
- args (List[str]): Container arguments
- env (List[str]): Environment variables
- expose (List[Dict]): Exposed ports configuration
  - port (int): Port number
  - as (int): External port mapping
  - accept (List[str]): Accepted hostnames
  - to (List[Dict]): Service routing
    - service (str): Target service name
- resources (Dict): Resource requirements
  - cpu (Dict): CPU allocation
    - units (str): CPU units
  - memory (Dict): Memory allocation
    - quantity (str): Memory quantity
  - storage (List[Dict]): Storage allocation
    - quantity (str): Storage quantity
created_at (int): Block height when order was created

Example:

from akash import AkashClient

client = AkashClient("https://akash-rpc.polkachu.com:443")

order = client.market.get_order(owner="akash1...", dseq=12345)
if order:
    print(f"Order state: {order['state']}")
    print(f"Resources: {order['spec']['resources']}")