Models and types

Data models, type definitions, and structures used in the Wax Python SDK

The Wax SDK uses various data models and type definitions to represent blockchain entities and structures.

Basic types

Fundamental type aliases for blockchain identifiers and data.

from wax.models.basic import (
    AccountName,
    Hex,
    ChainId,
    TransactionId,
    SigDigest,
    Signature,
    HeadBlockId,
    PublicKey
)

account: AccountName = "alice"
chain_id: ChainId = "beeab0de00000000000000000000000000000000000000000000000000000000"
tx_id: TransactionId = "f3a1b2c3..."
public_key: PublicKey = "STM7..."

AccountName · str

Account name on the Hive blockchain (3-16 characters, lowercase, digits, hyphens).

Hex · str

Hexadecimal string.

ChainId · Hex

Chain identifier in hexadecimal format.

TransactionId · Hex

Transaction identifier in hexadecimal format.

SigDigest · Hex

Signature digest in hexadecimal format.

Signature · Hex

Transaction signature in hexadecimal format.

HeadBlockId · Hex

Head block identifier in hexadecimal format.

PublicKey · str

Public key in WIF format (e.g., “STM7…”).

---

Asset types

Types and models for working with Hive blockchain assets (HIVE, HBD, VESTS).

Asset type aliases

from wax.models.asset import (
    AssetAmount,
    NaiAsset,
    HiveNaiAssetConvertible,
    HbdNaiAssetConvertible,
    VestsNaiAssetConvertible,
    AnyNaiAssetConvertible
)

# Create assets
wax = create_wax_foundation()
hive_asset: NaiAsset = wax.hive.coins(10.5)
hbd_asset: NaiAsset = wax.hbd.satoshis(5000)

AssetAmount · int | float | Decimal

Numeric type that can represent an asset amount.

NaiAsset · proto_asset

Asset in NAI (Number Asset Identifier) format - the HF26 standard format.

HiveNaiAssetConvertible · NaiAsset | dict | str

Types that can be converted to HIVE NAI format.

HbdNaiAssetConvertible · NaiAsset | dict | str

Types that can be converted to HBD NAI format.

VestsNaiAssetConvertible · NaiAsset | dict | str

Types that can be converted to VESTS NAI format.

AnyNaiAssetConvertible · HiveNaiAssetConvertible | HbdNaiAssetConvertible | VestsNaiAssetConvertible

Any type convertible to NAI asset format.

---

AssetName enum

Enumeration of asset names.

from wax.models.asset import AssetName

print(AssetName.Hive.value)   # "HIVE"
print(AssetName.Hbd.value)    # "HBD"
print(AssetName.Vests.value)  # "VESTS"

AssetName.Hive · Enum

HIVE token.

AssetName.Hbd · Enum

Hive Backed Dollar token.

AssetName.Vests · Enum

VESTS (Hive Power) token.

---

AssetInfo dataclass

Asset metadata information.

from wax.models.asset import AssetInfo

hive_info = AssetInfo(nai="@@000000021", precision=3)
hbd_info = AssetInfo(nai="@@000000013", precision=3)
vests_info = AssetInfo(nai="@@000000037", precision=6)

AssetInfo · dataclass

Contains asset metadata:

• nai: Number Asset Identifier string
• precision: Decimal precision (3 for HIVE/HBD, 6 for VESTS)

---

AssetFactory protocol

Factory interface for creating assets.

from wax import create_wax_foundation

wax = create_wax_foundation()

# Each asset factory implements this protocol
hive_factory = wax.hive
hbd_factory = wax.hbd
vests_factory = wax.vests

# Create from coins (with precision)
asset1 = hive_factory.coins(10.5)  # 10.500 HIVE

# Create from satoshis (no precision)
asset2 = hive_factory.satoshis(10500)  # 10.500 HIVE

AssetFactory · Protocol

Protocol with methods:

• coins(amount: AssetAmount) -> NaiAsset - Create from decimal amount
• satoshis(amount: int) -> NaiAsset - Create from integer satoshis

---

Authority types

Types for account authorities and permissions.

Authority type aliases

from wax.models.authority import (
    WaxAuthority,
    KeyAuths,
    AccountAuths
)

# Key authorities (public key -> weight)
key_auths: KeyAuths = {
    "STM7...": 1,
    "STM8...": 1
}

# Account authorities (account name -> weight)
account_auths: AccountAuths = {
    "alice": 1,
    "bob": 1
}

WaxAuthority · proto_authority

Authority structure containing weight threshold and authorized keys/accounts.

KeyAuths · dict[PublicKey, int]

Dictionary mapping public keys to their weight in an authority.

AccountAuths · dict[AccountName, int]

Dictionary mapping account names to their weight in an authority.

---

WaxAuthorities dataclass

Container for all account authorities.

from wax.models.authority import WaxAuthorities
from wax.proto.authority import authority

authorities = WaxAuthorities(
    owner=authority(
        weight_threshold=1,
        account_auths={},
        key_auths={"STM7owner...": 1}
    ),
    active=authority(
        weight_threshold=1,
        account_auths={},
        key_auths={"STM7active...": 1}
    ),
    posting=authority(
        weight_threshold=1,
        account_auths={"hive.blog": 1},
        key_auths={"STM7posting...": 1}
    )
)

print(authorities.owner.weight_threshold)
print(authorities.posting.account_auths)

WaxAuthorities · dataclass

Contains account authorities:

• owner: Owner authority (highest level)
• active: Active authority (financial operations)
• posting: Posting authority (content operations)

---

WaxAccountAuthorityInfo dataclass

Complete authority information for an account.

import asyncio
from wax import create_hive_chain

async def main():
    chain = create_hive_chain()
    
    auth_info = await chain.collect_account_authorities("alice")
    
    print(f"Account: {auth_info.account}")
    print(f"Memo key: {auth_info.memo_key}")
    print(f"Owner keys: {list(auth_info.authorities.owner.key_auths.keys())}")
    print(f"Last owner update: {auth_info.last_owner_update}")
    
    chain.teardown()

asyncio.run(main())

WaxAccountAuthorityInfo · dataclass

Contains:

• account: Account name
• authorities: WaxAuthorities object with owner/active/posting
• memo_key: Public memo key
• last_owner_update: Last owner authority update time
• previous_owner_update: Previous owner authority update time

---

ITransactionRequiredAuthorities interface

Interface for accessing required authorities from transactions.

from wax import create_wax_foundation
from wax.proto.operations import transfer, vote

wax = create_wax_foundation()
tx = wax.create_transaction_with_tapos(tapos_block_id="...")

tx.push_operation(
    transfer(from_account="alice", to_account="bob", amount=wax.hive.satoshis(1000), memo="")
)
tx.push_operation(
    vote(voter="alice", author="bob", permlink="post", weight=10000)
)

auths = tx.required_authorities

print("Posting accounts:", auths.posting_accounts)  # {"alice"}
print("Active accounts:", auths.active_accounts)    # {"alice"}
print("Owner accounts:", auths.owner_accounts)      # set()
print("Other authorities:", auths.other_authorities) # []

ITransactionRequiredAuthorities · interface

Properties:

• posting_accounts: Set of accounts requiring posting authority
• active_accounts: Set of accounts requiring active authority
• owner_accounts: Set of accounts requiring owner authority
• other_authorities: List of custom authority structures

---

Key data interfaces

Interfaces for private key and brain key data.

IPrivateKeyData interface

from wax import create_wax_foundation

wax = create_wax_foundation()

key_data = wax.get_private_key_from_password(
    account="alice",
    role="posting",
    password="master-password"
)

print(key_data.wif_private_key)        # "5J..."
print(key_data.associated_public_key)  # "STM7..."

IPrivateKeyData · interface

Properties:

• wif_private_key: Private key in WIF format
• associated_public_key: Associated public key in WIF format

---

IBrainKeyData interface

from wax import create_wax_foundation

wax = create_wax_foundation()

brain_key_data = wax.suggest_brain_key()

print(brain_key_data.brain_key)                # "WORD WORD WORD..."
print(brain_key_data.wif_private_key)          # "5J..."
print(brain_key_data.associated_public_key)    # "STM7..."

IBrainKeyData · interface

Extends IPrivateKeyData with:

• brain_key: Space-separated brain key words
• wif_private_key: Derived private key
• associated_public_key: Associated public key

---

Manabar data

IManabarData interface

Interface for manabar calculation results.

from datetime import datetime
from wax import create_wax_foundation

wax = create_wax_foundation()

manabar = wax.calculate_current_manabar_value(
    head_block_time=datetime.now(),
    max_mana=1000000,
    current_mana=500000,
    last_update_time=1234567890
)

print(f"Max mana: {manabar.max_mana}")
print(f"Current mana: {manabar.current_mana}")
print(f"Percent: {manabar.percent}%")

IManabarData · interface

Properties:

• max_mana: Maximum mana capacity
• current_mana: Current regenerated mana value
• percent: Manabar percentage (0-100)

---

Transaction types

Type aliases for different transaction formats.

from wax.transaction_type_aliases import ProtoTransaction, JsonTransaction

# Proto transaction (protobuf format)
proto_tx: ProtoTransaction = tx.transaction

# JSON transaction (API format)
json_tx: JsonTransaction = tx.to_api_json()

ProtoTransaction · proto_transaction

Transaction in protocol buffer format.

JsonTransaction · str

Transaction in JSON string format for Hive API calls.

---

Operation types

Type aliases for operation formats.

from wax.models.operations import (
    Operation,
    WaxMetaOperation,
    ProtoOperation,
    ProtocolOperation
)

# Any operation format
op: Operation = transfer(...)

# Proto operation
proto_op: ProtoOperation = transfer(...)

Operation · ProtoOperation | ProtocolOperation

Union of proto and protocol operation formats.

WaxMetaOperation · Message | OperationBase

Internal operation representation.

ProtoOperation · dict | str | Message

Types convertible to proto operation.

ProtocolOperation · dict | str

Operation in HF26 protocol format.

---

Configuration types

ChainConfig type

from wax import create_wax_foundation

wax = create_wax_foundation()
config: dict[str, str] = wax.config

print(config["HIVE_CHAIN_ID"])
print(config["HIVE_ADDRESS_PREFIX"])
print(config["HIVE_BLOCK_INTERVAL"])

ChainConfig · dict[str, str]

Dictionary containing chain configuration parameters like block interval, address prefix, and protocol constants.

---

TTimestamp type

from datetime import datetime, timedelta
from wax.interfaces import TTimestamp

# Absolute time
expiration: TTimestamp = datetime(2024, 12, 31, 23, 59, 59)

# Relative time
expiration: TTimestamp = timedelta(minutes=5)

TTimestamp · datetime | timedelta

Type alias for timestamps - can be absolute (datetime) or relative (timedelta).

---

Complete example

import asyncio
from datetime import datetime, timedelta
from wax import create_hive_chain
from wax.models.basic import AccountName, PublicKey
from wax.models.asset import NaiAsset
from wax.models.authority import WaxAccountAuthorityInfo
from wax.proto.operations import transfer

async def main():
    chain = create_hive_chain()
    
    try:
        # Use type annotations
        sender: AccountName = "alice"
        receiver: AccountName = "bob"
        amount: NaiAsset = chain.hive.satoshis(1000)
        
        # Get authority info
        auth_info: WaxAccountAuthorityInfo = await chain.collect_account_authorities(sender)
        posting_keys: list[PublicKey] = list(auth_info.authorities.posting.key_auths.keys())
        
        print(f"Account: {auth_info.account}")
        print(f"Posting keys: {posting_keys}")
        print(f"Memo key: {auth_info.memo_key}")
        
        # Create transaction
        tx = await chain.create_transaction(expiration=timedelta(minutes=2))
        tx.push_operation(
            transfer(
                from_account=sender,
                to_account=receiver,
                amount=amount,
                memo="Payment"
            )
        )
        
        # Get transaction info
        print(f"Transaction ID: {tx.id}")
        print(f"Impacted accounts: {tx.impacted_accounts}")
        print(f"Required authorities: {tx.required_authorities.active_accounts}")
        
    finally:
        chain.teardown()

asyncio.run(main())