objects.py

# -*- coding: utf-8 -*-
import json

from collections import OrderedDict

from graphenebase.objects import GrapheneObject
from graphenebase.objects import Operation as GrapheneOperation
from graphenebase.objects import isArgsThisClass, Asset
from graphenebase.types import Array, Bool, Bytes, Fixed_array, Id, Int16, Int64, Map
from graphenebase.types import ObjectId as GPHObjectId
from graphenebase.types import (
    Optional,
    PointInTime,
    Set,
    Signature,
    Static_variant,
    String,
    Uint8,
    Uint16,
    Uint32,
    Uint64,
    Varint32,
    Void,
    VoteId,
    Ripemd160,
)

from .account import PublicKey
from .objecttypes import object_type
from .operationids import operations


default_prefix = "BTS"

BlockId = Ripemd160


class Operation(GrapheneOperation):
    """Need to overwrite a few attributes to load proper operations from bitshares."""

    module = "bitsharesbase.operations"
    operations = operations


class ObjectId(GPHObjectId):
    """Need to overwrite a few attributes to load proper object_types from bitshares."""

    object_types = object_type


def AssetId(asset):
    return ObjectId(asset, "asset")


def AccountId(asset):
    return ObjectId(asset, "account")


class Memo(GrapheneObject):
    def __init__(self, *args, **kwargs):
        if isArgsThisClass(self, args):
            self.data = args[0].data
        else:
            if len(args) == 1 and len(kwargs) == 0:
                kwargs = args[0]
            prefix = kwargs.pop("prefix", default_prefix)
            if "message" in kwargs and kwargs["message"]:
                super().__init__(
                    OrderedDict(
                        [
                            ("from", PublicKey(kwargs["from"], prefix=prefix)),
                            ("to", PublicKey(kwargs["to"], prefix=prefix)),
                            ("nonce", Uint64(int(kwargs["nonce"]))),
                            ("message", Bytes(kwargs["message"])),
                        ]
                    )
                )
            else:
                super().__init__(None)


class Price(GrapheneObject):
    def __init__(self, *args, **kwargs):
        if isArgsThisClass(self, args):
            self.data = args[0].data
        else:
            if len(args) == 1 and len(kwargs) == 0:
                kwargs = args[0]
            super().__init__(
                OrderedDict(
                    [("base", Asset(kwargs["base"])), ("quote", Asset(kwargs["quote"]))]
                )
            )


class PriceFeed(GrapheneObject):
    def __init__(self, *args, **kwargs):
        if isArgsThisClass(self, args):
            self.data = args[0].data
        else:
            if len(args) == 1 and len(kwargs) == 0:
                kwargs = args[0]
            super().__init__(
                OrderedDict(
                    [
                        ("settlement_price", Price(kwargs["settlement_price"])),
                        (
                            "maintenance_collateral_ratio",
                            Uint16(kwargs["maintenance_collateral_ratio"]),
                        ),
                        (
                            "maximum_short_squeeze_ratio",
                            Uint16(kwargs["maximum_short_squeeze_ratio"]),
                        ),
                        ("core_exchange_rate", Price(kwargs["core_exchange_rate"])),
                    ]
                )
            )


class Permission(GrapheneObject):
    def __init__(self, *args, **kwargs):
        if isArgsThisClass(self, args):
            self.data = args[0].data
        else:
            prefix = kwargs.pop("prefix", default_prefix)

            if len(args) == 1 and len(kwargs) == 0:
                kwargs = args[0]
            kwargs["key_auths"] = sorted(
                kwargs["key_auths"],
                key=lambda x: PublicKey(x[0], prefix=prefix),
                reverse=False,
            )
            accountAuths = Map(
                [
                    [ObjectId(e[0], "account"), Uint16(e[1])]
                    for e in kwargs["account_auths"]
                ]
            )
            keyAuths = Map(
                [
                    [PublicKey(e[0], prefix=prefix), Uint16(e[1])]
                    for e in kwargs["key_auths"]
                ]
            )
            super().__init__(
                OrderedDict(
                    [
                        ("weight_threshold", Uint32(int(kwargs["weight_threshold"]))),
                        ("account_auths", accountAuths),
                        ("key_auths", keyAuths),
                        ("extensions", Set([])),
                    ]
                )
            )


class AccountOptions(GrapheneObject):
    def __init__(self, *args, **kwargs):
        # Allow for overwrite of prefix
        prefix = kwargs.pop("prefix", default_prefix)

        if isArgsThisClass(self, args):
            self.data = args[0].data
        else:
            if len(args) == 1 and len(kwargs) == 0:
                kwargs = args[0]
            # remove dublicates
            kwargs["votes"] = list(set(kwargs["votes"]))
            # Sort votes
            kwargs["votes"] = sorted(
                kwargs["votes"], key=lambda x: float(x.split(":")[1])
            )
            super().__init__(
                OrderedDict(
                    [
                        ("memo_key", PublicKey(kwargs["memo_key"], prefix=prefix)),
                        (
                            "voting_account",
                            ObjectId(kwargs["voting_account"], "account"),
                        ),
                        ("num_witness", Uint16(kwargs["num_witness"])),
                        ("num_committee", Uint16(kwargs["num_committee"])),
                        ("votes", Array([VoteId(o) for o in kwargs["votes"]])),
                        ("extensions", Set([])),
                    ]
                )
            )


class AssetOptions(GrapheneObject):
    def __init__(self, *args, **kwargs):
        if isArgsThisClass(self, args):
            self.data = args[0].data
        else:
            if len(args) == 1 and len(kwargs) == 0:
                kwargs = args[0]
            super().__init__(
                OrderedDict(
                    [
                        ("max_supply", Int64(kwargs["max_supply"])),
                        ("market_fee_percent", Uint16(kwargs["market_fee_percent"])),
                        ("max_market_fee", Int64(kwargs["max_market_fee"])),
                        ("issuer_permissions", Uint16(kwargs["issuer_permissions"])),
                        ("flags", Uint16(kwargs["flags"])),
                        ("core_exchange_rate", Price(kwargs["core_exchange_rate"])),
                        (
                            "whitelist_authorities",
                            Array(
                                [
                                    ObjectId(x, "account")
                                    for x in kwargs["whitelist_authorities"]
                                ]
                            ),
                        ),
                        (
                            "blacklist_authorities",
                            Array(
                                [
                                    ObjectId(x, "account")
                                    for x in kwargs["blacklist_authorities"]
                                ]
                            ),
                        ),
                        (
                            "whitelist_markets",
                            Array(
                                [
                                    ObjectId(x, "asset")
                                    for x in kwargs["whitelist_markets"]
                                ]
                            ),
                        ),
                        (
                            "blacklist_markets",
                            Array(
                                [
                                    ObjectId(x, "asset")
                                    for x in kwargs["blacklist_markets"]
                                ]
                            ),
                        ),
                        ("description", String(kwargs["description"])),
                        ("extensions", Set([])),
                    ]
                )
            )


class BitAssetOptions(GrapheneObject):
    def __init__(self, *args, **kwargs):
        if isArgsThisClass(self, args):
            self.data = args[0].data
        else:
            if len(args) == 1 and len(kwargs) == 0:
                kwargs = args[0]
            super().__init__(
                OrderedDict(
                    [
                        ("feed_lifetime_sec", Uint32(kwargs["feed_lifetime_sec"])),
                        ("minimum_feeds", Uint8(kwargs["minimum_feeds"])),
                        (
                            "force_settlement_delay_sec",
                            Uint32(kwargs["force_settlement_delay_sec"]),
                        ),
                        (
                            "force_settlement_offset_percent",
                            Uint16(kwargs["force_settlement_offset_percent"]),
                        ),
                        (
                            "maximum_force_settlement_volume",
                            Uint16(kwargs["maximum_force_settlement_volume"]),
                        ),
                        (
                            "short_backing_asset",
                            ObjectId(kwargs["short_backing_asset"], "asset"),
                        ),
                        ("extensions", Set([])),
                    ]
                )
            )


class Worker_initializer(Static_variant):
    def __init__(self, o):
        class Burn_worker_initializer(GrapheneObject):
            def __init__(self, kwargs):
                super().__init__(OrderedDict([]))

        class Refund_worker_initializer(GrapheneObject):
            def __init__(self, kwargs):
                super().__init__(OrderedDict([]))

        class Vesting_balance_worker_initializer(GrapheneObject):
            def __init__(self, *args, **kwargs):
                if isArgsThisClass(self, args):
                    self.data = args[0].data
                else:
                    if len(args) == 1 and len(kwargs) == 0:
                        kwargs = args[0]
                    super().__init__(
                        OrderedDict(
                            [
                                (
                                    "pay_vesting_period_days",
                                    Uint16(kwargs["pay_vesting_period_days"]),
                                )
                            ]
                        )
                    )

        id = o[0]
        if id == 0:
            data = Refund_worker_initializer(o[1])
        elif id == 1:
            data = Vesting_balance_worker_initializer(o[1])
        elif id == 2:
            data = Burn_worker_initializer(o[1])
        else:
            raise ValueError("Unknown {}".format(self.__class__.name))
        super().__init__(data, id)


class SpecialAuthority(Static_variant):
    def __init__(self, o):
        class No_special_authority(GrapheneObject):
            def __init__(self, kwargs):
                super().__init__(OrderedDict([]))

        class Top_holders_special_authority(GrapheneObject):
            def __init__(self, kwargs):
                super().__init__(
                    OrderedDict(
                        [
                            ("asset", ObjectId(kwargs["asset"], "asset")),
                            ("num_top_holders", Uint8(kwargs["num_top_holders"])),
                        ]
                    )
                )

        id = o[0]
        if id == 0:
            data = No_special_authority(o[1])
        elif id == 1:
            data = Top_holders_special_authority(o[1])
        else:
            raise Exception("Unknown SpecialAuthority")
        super().__init__(data, id)


class Extension(Array):
    def __init__(self, *args, **kwargs):
        self.json = {}
        a = []
        for key, value in kwargs.items():
            self.json.update({key: value})
        for arg in args:
            if isinstance(arg, dict):
                self.json.update(arg)

        for index, extension in enumerate(self.sorted_options):
            name = extension[0]
            klass = extension[1]
            for key, value in self.json.items():
                if key.lower() == name.lower():
                    a.append(Static_variant(klass(value), index))
        super().__init__(a)

    def __str__(self):
        """We overload the __str__ function because the json representation is different
        for extensions."""
        return json.dumps(self.json)


class AccountCreateExtensions(Extension):
    class Null_ext(GrapheneObject):
        def __init__(self, *args, **kwargs):
            super().__init__(OrderedDict([]))

    class Buyback_options(GrapheneObject):
        def __init__(self, *args, **kwargs):
            kwargs.update(args[0])
            super().__init__(
                OrderedDict(
                    [
                        ("asset_to_buy", ObjectId(kwargs["asset_to_buy"], "asset")),
                        (
                            "asset_to_buy_issuer",
                            ObjectId(kwargs["asset_to_buy_issuer"], "account"),
                        ),
                        (
                            "markets",
                            Array([ObjectId(x, "asset") for x in kwargs["markets"]]),
                        ),
                    ]
                )
            )

    sorted_options = [
        ("null_ext", Null_ext),
        ("owner_special_authority", SpecialAuthority),
        ("active_special_authority", SpecialAuthority),
        ("buyback_options", Buyback_options),
    ]


class CallOrderExtension(Extension):
    def targetCollateralRatio(value):
        if value:
            return Uint16(value)
        else:
            return None

    sorted_options = [("target_collateral_ratio", targetCollateralRatio)]


class AssertPredicate(Static_variant):
    def __init__(self, o):
        class Account_name_eq_lit_predicate(GrapheneObject):
            def __init__(self, *args, **kwargs):
                kwargs.update(args[0])
                super().__init__(
                    OrderedDict(
                        [
                            ("account_id", ObjectId(kwargs["account_id"], "account")),
                            ("name", String(kwargs["name"])),
                        ]
                    )
                )

        class Asset_symbol_eq_lit_predicate(GrapheneObject):
            def __init__(self, *args, **kwargs):
                kwargs.update(args[0])
                super().__init__(
                    OrderedDict(
                        [
                            ("asset_id", ObjectId(kwargs["asset_id"], "asset")),
                            ("symbol", String(kwargs["symbol"])),
                        ]
                    )
                )

        class Block_id_predicate(GrapheneObject):
            def __init__(self, *args, **kwargs):
                kwargs.update(args[0])
                super().__init__(OrderedDict([("id", BlockId(kwargs["id"]))]))

        id = o[0]
        if id == 0:
            data = Account_name_eq_lit_predicate(o[1])
        elif id == 1:
            data = Asset_symbol_eq_lit_predicate(o[1])
        elif id == 2:
            data = Block_id_predicate(o[1])
        else:
            raise ValueError("Unknown {}".format(self.__class__.__name__))
        super().__init__(data, id)


class LimitOrderAutoAction(Static_variant):
    def __init__(self, o):
        class Create_take_profit_order_action(GrapheneObject):
            def __init__(self, *args, **kwargs):
                kwargs.update(args[0])
                super().__init__(
                    OrderedDict(
                        [
                            ("fee_asset_id", ObjectId(kwargs["fee_asset_id"], "asset")),
                            ("spread_percent", Uint16(kwargs["spread_percent"])),
                            ("size_percent", Uint16(kwargs["size_percent"])),
                            (
                                "expiration_seconds",
                                Uint32(kwargs["expiration_seconds"]),
                            ),
                            ("repeat", Bool(kwargs["repeat"])),
                            ("extensions", Set([])),
                        ]
                    )
                )

        id = o[0]
        if id == 0:
            data = Create_take_profit_order_action(o[1])
        else:
            raise ValueError("Unknown {}".format(self.__class__.__name__))
        super().__init__(data, id)


class LimitOrderCreateExtensions(Extension):
    def NestedLimitOrderAutoAction(value):
        if value:
            return Array([LimitOrderAutoAction(o) for o in value])
        else:
            return None

    sorted_options = [
        ("on_fill", NestedLimitOrderAutoAction),
    ]