pinknetworkx / atomicassets-contract Goto Github PK

assertion failure with message: datastream attempted to read past the end
{
  "code": 500,
  "message": "Internal Service Error",
  "error": {
    "code": 3050003,
    "name": "eosio_assert_message_exception",
    "what": "eosio_assert_message assertion failure",
    "details": [
      {
        "message": "assertion failure with message: datastream attempted to read past the end",
        "file": "wasm_interface.cpp",
        "line_number": 1075,
        "method": "eosio_assert"
      }
    ]
  }
}

/*

This file is not used for the actual atomicassets contract.
It can be used as a header file for other contracts to access the atomicassets tables
and custom data types.

*/
#pragma once

#include <eosio/eosio.hpp>
#include <eosio/singleton.hpp>
#include <eosio/asset.hpp>

using namespace eosio;
using namespace std;

namespace atomicassets {
    static constexpr double MAX_MARKET_FEE = 0.15;

    static const name ATOMICASSETS_ACCOUNT = name("atomicassets");

    //Custom vector types need to be defined because otherwise a bug in the ABI serialization
    //would cause the ABI to be invalid
    typedef std::vector <int8_t>      INT8_VEC;
    typedef std::vector <int16_t>     INT16_VEC;
    typedef std::vector <int32_t>     INT32_VEC;
    typedef std::vector <int64_t>     INT64_VEC;
    typedef std::vector <uint8_t>     UINT8_VEC;
    typedef std::vector <uint16_t>    UINT16_VEC;
    typedef std::vector <uint32_t>    UINT32_VEC;
    typedef std::vector <uint64_t>    UINT64_VEC;
    typedef std::vector <float>       FLOAT_VEC;
    typedef std::vector <double>      DOUBLE_VEC;
    typedef std::vector <std::string> STRING_VEC;

    typedef std::variant <\
        int8_t, int16_t, int32_t, int64_t, \
        uint8_t, uint16_t, uint32_t, uint64_t, \
        float, double, std::string, \
        INT8_VEC, INT16_VEC, INT32_VEC, INT64_VEC, \
        UINT8_VEC, UINT16_VEC, UINT32_VEC, UINT64_VEC, \
        FLOAT_VEC, DOUBLE_VEC, STRING_VEC
    > ATOMIC_ATTRIBUTE;

    typedef std::map <std::string, ATOMIC_ATTRIBUTE> ATTRIBUTE_MAP;

    struct FORMAT {
        string name;
        string type;
    };

    struct collections_s {
        name             collection_name;
        name             author;
        bool             allow_notify;
        vector <name>    authorized_accounts;
        vector <name>    notify_accounts;
        double           market_fee;
        vector <uint8_t> serialized_data;

        uint64_t primary_key() const { return collection_name.value; };
    };
    EOSIO_REFLECT(collections_s, collection_name, author, allow_notify, authorized_accounts, notify_accounts, market_fee, serialized_data);
    typedef multi_index <name("collections"), collections_s> collections_t;


    //Scope: collection_name
    struct schemas_s {
        name            schema_name;
        vector <FORMAT> format;

        uint64_t primary_key() const { return schema_name.value; }
    };
    EOSIO_REFLECT(schemas_s, schema_name, format);
    typedef multi_index <name("schemas"), schemas_s> schemas_t;


    //Scope: collection_name
    struct templates_s {
        int32_t          template_id;
        name             schema_name;
        bool             transferable;
        bool             burnable;
        uint32_t         max_supply;
        uint32_t         issued_supply;
        vector <uint8_t> immutable_serialized_data;

        uint64_t primary_key() const { return (uint64_t) template_id; }
    };
    EOSIO_REFLECT(templates_s, template_id, schema_name, transferable, burnable, max_supply, issued_supply, immutable_serialized_data);
    typedef multi_index <name("templates"), templates_s> templates_t;


    //Scope: owner
    struct assets_s {
        uint64_t         asset_id;
        name             collection_name;
        name             schema_name;
        int32_t          template_id;
        name             ram_payer;
        vector <asset>   backed_tokens;
        vector <uint8_t> immutable_serialized_data;
        vector <uint8_t> mutable_serialized_data;

        uint64_t primary_key() const { return asset_id; };
    };
    EOSIO_REFLECT(assets_s, collection_name, schema_name, template_id, ram_payer, backed_tokens, immutable_serialized_data, mutable_serialized_data);
    typedef multi_index <name("assets"), assets_s> assets_t;


    struct offers_s {
        uint64_t          offer_id;
        name              sender;
        name              recipient;
        vector <uint64_t> sender_asset_ids;
        vector <uint64_t> recipient_asset_ids;
        string            memo;
        name              ram_payer;

        uint64_t primary_key() const { return offer_id; };

        uint64_t by_sender() const { return sender.value; };

        uint64_t by_recipient() const { return recipient.value; };
    };
    EOSIO_REFLECT(offers_s, sender, recipient, sender_asset_ids, recipient_asset_ids, memo, ram_payer);
    typedef multi_index <name("offers"), offers_s,
        indexed_by < name("sender"), const_mem_fun < offers_s, uint64_t, &offers_s::by_sender>>,
    indexed_by <name("recipient"), const_mem_fun < offers_s, uint64_t, &offers_s::by_recipient>>>
    offers_t;

    struct balances_s {
        name           owner;
        vector <asset> quantities;

        uint64_t primary_key() const { return owner.value; };
    };
    EOSIO_REFLECT(balances_s, owner, quantities);
    typedef multi_index <name("balances"), balances_s>       balances_t;

    struct config_s {
        uint64_t                 asset_counter     = 1099511627776; //2^40
        int32_t                  template_counter  = 1;
        uint64_t                 offer_counter     = 1;
        vector <FORMAT>          collection_format = {};
        vector <extended_symbol> supported_tokens  = {};
    };
    EOSIO_REFLECT(config_s, asset_counter, template_counter, offer_counter, collection_format, supported_tokens);
    typedef singleton <name("config"), config_s>             config_t;

    struct tokenconfigs_s {
        name        standard = name("atomicassets");
        std::string version  = string("1.2.3");
    };
    EOSIO_REFLECT(tokenconfigs_s, standard, version);
    typedef singleton <name("tokenconfigs"), tokenconfigs_s> tokenconfigs_t;

    static collections_t  collections  = collections_t(ATOMICASSETS_ACCOUNT, ATOMICASSETS_ACCOUNT.value);
    static offers_t       offers       = offers_t(ATOMICASSETS_ACCOUNT, ATOMICASSETS_ACCOUNT.value);
    static balances_t     balances     = balances_t(ATOMICASSETS_ACCOUNT, ATOMICASSETS_ACCOUNT.value);
    static config_t       config       = config_t(ATOMICASSETS_ACCOUNT, ATOMICASSETS_ACCOUNT.value);
    static tokenconfigs_t tokenconfigs = tokenconfigs_t(ATOMICASSETS_ACCOUNT, ATOMICASSETS_ACCOUNT.value);

    assets_t inline get_assets(name acc) {
        return assets_t(ATOMICASSETS_ACCOUNT, acc.value);
    }

    schemas_t inline get_schemas(name collection_name) {
        return schemas_t(ATOMICASSETS_ACCOUNT, collection_name.value);
    }

    templates_t inline get_templates(name collection_name) {
        return templates_t(ATOMICASSETS_ACCOUNT, collection_name.value);
    }
};