enum AssetPolicy
{
  //: Defines whether or not asset can be transfered using payments
	TRANSFERABLE = 1,
	//: Defines whether or not asset is considered base
	BASE_ASSET = 2,
	//: [[Deprecated]]
	STATS_QUOTE_ASSET = 4,
	//: Defines whether or not asset can be withdrawed from the system
	WITHDRAWABLE = 8,
	//: Defines whether or not manual review for issuance of asset is required
	ISSUANCE_MANUAL_REVIEW_REQUIRED = 16,
	//: Defines whether or not asset can be base in atomic swap
	CAN_BE_BASE_IN_ATOMIC_SWAP = 32,
	//: Defines whether or not asset can be quote in atomic swap
	CAN_BE_QUOTE_IN_ATOMIC_SWAP = 64
};


struct AssetEntry
{
  //: Code of the asset
  AssetCode code;
  //: Owner(creator) of the asset
	AccountID owner;
	//: Account responsible for preissuance of the asset
	AccountID preissuedAssetSigner;
    //: Arbitrary stringified JSON object that can be used to attach data to asset
	longstring details;
	//: Maximal amount of tokens that can be issued
	uint64 maxIssuanceAmount;
	//: Amount of tokens available for issuance
	uint64 availableForIssueance;
	//: Amount of tokens issued already
	uint64 issued;
	//: Amount of tokens to be issued which is locked. `pendingIssuance+issued <= maxIssuanceAmount`
	uint64 pendingIssuance;
	//: Policies of the asset
  uint32 policies;
  //: Used to restrict usage. Used in account rules
  uint64 type;
  //: Number of decimal places. Must be <= 6
  uint32 trailingDigitsCount;

  //: Reserved for future use
  EmptyExt ext;
};

//: `FeeType` represents different types of fees for different operations (e.g. fee charged on withdrawal or on investment)
enum FeeType
{
    PAYMENT_FEE = 0,
    OFFER_FEE = 1,
    WITHDRAWAL_FEE = 2,
    ISSUANCE_FEE = 3,
    INVEST_FEE = 4, // fee to be taken while creating the sale participation
    CAPITAL_DEPLOYMENT_FEE = 5, // fee to be taken when the sale closes
    OPERATION_FEE = 6,
    PAYOUT_FEE = 7,
    ATOMIC_SWAP_SALE_FEE = 8,
    ATOMIC_SWAP_PURCHASE_FEE = 9
};

//: (not used) `EmissionFeeType` is a subtype of `ISSUANCE_FEE`
enum EmissionFeeType
{
    PRIMARY_MARKET = 1,
    SECONDARY_MARKET = 2
};

//: `PaymentFeeType` is a subtype of the Fee used for payments
enum PaymentFeeType
{
    OUTGOING = 1,
    INCOMING = 2
};

//: `FeeEntry` is used in the system configuration to set fees for different assets, operations (according to FeeType), particular account roles, particular accounts,
//: or globally (only if both parameters particular account role and paticular account are not specified).
struct FeeEntry
{
    //: Type of a particular fee depending on the operation (e.g., PAYMENT_FEE for payment operation, WITHDRAWAL_FEE for withdrawal operation, etc.)
    FeeType feeType;
    //: Code of an asset used in the operation for which the fee will be charged
    AssetCode asset;

    //: Fixed amount of fee that will be charged for the operation
    int64 fixedFee;
    //: Percent from the operation amount that will be charged for the corresponding operation
    int64 percentFee;

    //: (optional) Account from which fee would be charged
    AccountID* accountID;
    //: (optional) Account role from which fee would be charged
    uint64*    accountRole;
    //: Defines a `subtype` of a fee if such exists (e.g., `OUTGOING` or `INCOMING` for `PAYMENT_FEE`)
    int64 subtype;

    //: Defines the lower bound of operation amount for which this fee is applicable
    int64 lowerBound;
    //: Defines the upper bound of operation amount for which this fee is applicable
    int64 upperBound;

    //: Hash of `type:<feeType>asset:<asset>subtype:<subtype>`
    //: (Add `accountID:<accountID>` or `accountRole:<accountRole>` if corresponding fields are defined)
    Hash hash;

    //: reserved for future use
    union switch (LedgerVersion v)
    {
    case EMPTY_VERSION:
        void;
    }
    ext;
};

struct LiquidityPoolEntry
{
  //: Unique sequential identifier of the liquidity pool
  uint64 id;

  //: Account that holds balances of the liquidity pool
  AccountID liquidityPoolAccount;

  //: Asset code of the LP token
  AssetCode lpTokenAssetCode;

  //: Balance of first asset
  BalanceID firstAssetBalance;
  //: Balance of second asset
  BalanceID secondAssetBalance;

  //: Total amount of all LP tokens
  uint64 lpTokensTotalCap;

  //: Amount of first asset stored in liquidity pool
  uint64 firstReserve;
  //: Amount of second asset stored in liquidity pool
  uint64 secondReserve;

  //: Reserved for future usage
  EmptyExt ext;
};

//: Describes properties of some entries that can be used to restrict the use of entries
union SignerRuleResource switch (LedgerEntryType type)
{
case REVIEWABLE_REQUEST:
    //: Describes properties which are equal to managed reviewable request entry fields
    struct
    {
        //: Describes properties of some reviewable request types that
        //: can be used to restrict the using of reviewable requests
        ReviewableRequestResource details;

        //: Bit mask of tasks which is allowed to add to reviewable request pending tasks
        uint64 tasksToAdd;
        //: Bit mask of tasks which is allowed to remove from reviewable request pending tasks
        uint64 tasksToRemove;
        //: Bit mask of tasks which is allowed to use as reviewable request pending tasks
        uint64 allTasks;

        EmptyExt ext;
    } reviewableRequest;
case ASSET:
    //: Describes properties which are equal to managed asset entry fields
    struct
    {
        AssetCode assetCode;
        uint64 assetType;

        EmptyExt ext;
    } asset;
case ANY:
    void;
case OFFER_ENTRY:
    //: Describes properties which are equal to managed offer entry fields and their properties
    struct
    {
        //: type of base asset
        uint64 baseAssetType;
        //: type of quote asset
        uint64 quoteAssetType;

        //: code of base asset
        AssetCode baseAssetCode;
        //: code of quote asset
        AssetCode quoteAssetCode;

        bool isBuy;

        EmptyExt ext;
    } offer;
case SALE:
    //: Describes properties which are equal to managed offer entry fields
    struct
    {
        uint64 saleID;
        uint64 saleType;

        EmptyExt ext;
    } sale;
case ATOMIC_SWAP_BID:
    struct
    {
        uint64 assetType;
        AssetCode assetCode;

        EmptyExt ext;
    } atomicSwapBid;
case SIGNER_RULE:
    //: Describes properties which are equal to managed signer rule entry fields
    struct
    {
        //: True means that resource will be triggered if default rule is managed
        //: or changing of `isDefault` property for signer rule
        bool isDefault;

        EmptyExt ext;
    } signerRule;
case SIGNER_ROLE:
    //: Describes properties which are equal to managed signer role entry fields
    struct
    {
        //: For signer role creating resource will be triggered if `roleID` equals `0`
        uint64 roleID;

        EmptyExt ext;
    } signerRole;
case SIGNER:
    //: Describes properties which are equal to managed signer entry fields
    struct
    {
        uint64 roleID;

        EmptyExt ext;
    } signer;
case KEY_VALUE:
    //: Describes properties which are equal to managed key value entry fields
    struct
    {
        //: prefix of key
        longstring keyPrefix;

        //: reserved for future extension
        EmptyExt ext;
    } keyValue;
default:
    //: reserved for future extension
    EmptyExt ext;
};

//: Describes properties of some entries that can be used to restrict the use of entries
union AccountRuleResource switch (LedgerEntryType type)
{
case ASSET:
    //: Describes properties which are equal to managed asset entry fields
    struct
    {
        AssetCode assetCode;
        uint64 assetType;

        EmptyExt ext;
    } asset;
case REVIEWABLE_REQUEST:
    //: Describes properties which are equal to managed reviewable request entry fields
    struct
    {
        //: Describes properties of some reviewable request types that
        //: can be used to restrict the using of reviewable requests
        ReviewableRequestResource details;

        //: reserved for future extension
        EmptyExt ext;
    } reviewableRequest;
case ANY:
    void;
case OFFER_ENTRY:
    //: Describes properties which are equal to managed offer entry fields and their properties
    struct
    {
        //: type of base asset
        uint64 baseAssetType;
        //: type of quote asset
        uint64 quoteAssetType;

        //: code of base asset
        AssetCode baseAssetCode;
        //: code of quote asset
        AssetCode quoteAssetCode;

        bool isBuy;

        //: reserved for future extension
        EmptyExt ext;
    } offer;
case SALE:
    //: Describes properties which are equal to managed offer entry fields
    struct
    {
        uint64 saleID;
        uint64 saleType;

        //: reserved for future extension
        EmptyExt ext;
    } sale;
case ATOMIC_SWAP_BID:
    struct
    {
        uint64 assetType;
        AssetCode assetCode;

        EmptyExt ext;
    } atomicSwapBid;
case KEY_VALUE:
    struct
    {
        //: prefix of key
        longstring keyPrefix;

        //: reserved for future extension
        EmptyExt ext;
    } keyValue;
default:
    //: reserved for future extension
    EmptyExt ext;
};

//: Describes properties of some reviewable request types that
//: can be used to restrict the using of reviewable requests
union ReviewableRequestResource switch (ReviewableRequestType requestType)
{
case CREATE_SALE:
    //: is used to restrict using of reviewable request with create_sale type
    struct
    {
        //: type of sale
        uint64 type;

        //: reserved for future extension
        EmptyExt ext;
    } createSale;
case CREATE_ISSUANCE:
    //: is used to restrict using of reviewable request with create_issuance type
    struct
    {
        //: code of asset
        AssetCode assetCode;
        //: type of asset
        uint64 assetType;

        //: reserved for future extension
        EmptyExt ext;
    } createIssuance;
case CREATE_WITHDRAW:
    //: is used to restrict using of reviewable request with create_withdraw type
    struct
    {
        //: code of asset
        AssetCode assetCode;
        //: type of asset
        uint64 assetType;

        //: reserved for future extension
        EmptyExt ext;
    } createWithdraw;
default:
    //: reserved for future extension
    EmptyExt ext;
};

//: Policies that could be applied to AssetPair entry and define applicable operations for AssetPair
enum AssetPairPolicy
{
    //: If not set pair can not be traded on secondary market
    TRADEABLE_SECONDARY_MARKET = 1,
    //: If set, then prices for new offers must be greater then physical price with correction
    PHYSICAL_PRICE_RESTRICTION = 2,
    //: if set, then price for new offers must be in interval of (1 ± maxPriceStep)*currentPrice
    CURRENT_PRICE_RESTRICTION = 4
};

//: `AssetPairEntry` is used in system to group different assets into pairs and set particular policies and properties for them
struct AssetPairEntry
{
    //: Code of base asset of the asset pair
    AssetCode base;
    //: Code of quote asset of the asset pair
    AssetCode quote;

    //: defines an asset pair price as quote asset divided by base asset (i.e., amount of quote asset per 1 base asset)
    int64 currentPrice;
    //: Price of the asset pair assigned on creation. Can only be updated by application
    //: the `ManageAssetPair` operation with action `UPDATE_PRICE`
    int64 physicalPrice;

    //: Price of the asset pair assigned on creation. Can only be updated by application
    //: the `ManageAssetPair` operation with action `UPDATE_PRICE`
    int64 physicalPriceCorrection;

    //: Max price step in percent. User is allowed to set offer only if both of
    //: `price < (1 - maxPriceStep) * currentPrice` and `price > (1 + maxPriceStep) * currentPrice` are `true`
    int64 maxPriceStep;

    //: Bitmask of asset policies set by creator or corrected by `ManageAssetPair` operations
    int32 policies;

    // reserved for future use
    union switch (LedgerVersion v)
    {
      case EMPTY_VERSION:
        void;
    }
    ext;
};