@xoxno/types 1.0.1

package/dist/cosmos-db/cosmos-db-query.d.ts

@@ -0,0 +1,81 @@
+import { SqlQuerySpec } from '@azure/cosmos';
+import { CosmosDbGenericFilter } from './cosmos-db-generic-filter';
+import { NftMetadataAttributes, NftMetadataAttributesType } from './documents/token/nft-metadata-attributes';
+export declare enum QueryConditionOperator {
+    EQUAL = "EQUAL",
+    NOT_EQUAL = "NOT_EQUAL",
+    GREATER_THAN = "GREATER_THAN",
+    LESS_THAN = "LESS_THAN",
+    GREATER_THAN_OR_EQUAL = "GREATER_THAN_OR_EQUAL",
+    LESS_THAN_OR_EQUAL = "LESS_THAN_OR_EQUAL",
+    IN = "IN",
+    NOT_IN = "NOT_IN"
+}
+export declare enum QueryLogicalOperator {
+    AND = "AND",
+    OR = "OR"
+}
+export declare enum QueryOrderDirection {
+    ASC = "asc",
+    DESC = "desc"
+}
+export interface QueryCondition {
+    field: string;
+    value: string | number | boolean | string[] | number[];
+    operator: QueryConditionOperator;
+    logicalOperator?: QueryLogicalOperator;
+}
+export interface QueryCustomCondition {
+    condition: string;
+    logicalOperator?: QueryLogicalOperator;
+    parameters?: {
+        [key: string]: string | number | boolean | string[] | number[];
+    };
+}
+export interface CosmosDbQuery {
+    selectFields?: string[];
+    conditions: QueryCondition[];
+    groupedConditions?: QueryConditionGroup[];
+    customConditions?: QueryCustomCondition[];
+    orderBy?: {
+        field: string;
+        direction: QueryOrderDirection;
+    };
+    skip?: number;
+    top?: number;
+}
+export interface QueryConditionGroup {
+    conditions: QueryCondition[];
+    logicalOperator: QueryLogicalOperator;
+}
+export declare class CosmosDbQueryBuilder {
+    private query;
+    private parameters;
+    private isCountQuery;
+    constructor();
+    where(field: string, value: string | number | boolean | string[] | number[], operator: QueryConditionOperator, logicalOperator?: QueryLogicalOperator): CosmosDbQueryBuilder;
+    whereCustom(condition: string, logicalOperator?: QueryLogicalOperator, parameters?: Record<string, string | number | boolean | string[] | number[]>): CosmosDbQueryBuilder;
+    whereRange(field: string, lower: number, upper: number, logicalOperator?: QueryLogicalOperator): CosmosDbQueryBuilder;
+    whereGroup(conditions: QueryCondition[], logicalOperator?: QueryLogicalOperator): CosmosDbQueryBuilder;
+    orderBy(field: string, direction: QueryOrderDirection): CosmosDbQueryBuilder;
+    setOffset(offset: number): CosmosDbQueryBuilder;
+    setLimit(limit: number): CosmosDbQueryBuilder;
+    selectFields(fields: string[]): CosmosDbQueryBuilder;
+    count(): this;
+    buildSqlQuery(applyPagination?: boolean): SqlQuerySpec;
+    private buildCustomProjection;
+    private getSqlOperator;
+    fromFilter(filter: CosmosDbGenericFilter): CosmosDbQueryBuilder;
+    getMintProfilePricesQueryAndParams(mintToken: string[]): {
+        filterString: string;
+        parameters: Record<string, string>;
+    };
+    getAttributesQueryAndParams(key: string, attributes: NftMetadataAttributes[], traitLogicalOperator?: QueryLogicalOperator): {
+        filterString: string;
+        parameters: Record<string, string>;
+    };
+    groupAttributesByTrait(attributes: NftMetadataAttributesType[]): {
+        trait_type: string;
+        values: string[];
+    }[];
+}

package/dist/cosmos-db/cosmos-db-query.js

@@ -0,0 +1,435 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CosmosDbQueryBuilder = exports.QueryOrderDirection = exports.QueryLogicalOperator = exports.QueryConditionOperator = void 0;
+const enums_1 = require("../common/enums");
+var QueryConditionOperator;
+(function (QueryConditionOperator) {
+    QueryConditionOperator["EQUAL"] = "EQUAL";
+    QueryConditionOperator["NOT_EQUAL"] = "NOT_EQUAL";
+    QueryConditionOperator["GREATER_THAN"] = "GREATER_THAN";
+    QueryConditionOperator["LESS_THAN"] = "LESS_THAN";
+    QueryConditionOperator["GREATER_THAN_OR_EQUAL"] = "GREATER_THAN_OR_EQUAL";
+    QueryConditionOperator["LESS_THAN_OR_EQUAL"] = "LESS_THAN_OR_EQUAL";
+    QueryConditionOperator["IN"] = "IN";
+    QueryConditionOperator["NOT_IN"] = "NOT_IN";
+})(QueryConditionOperator || (exports.QueryConditionOperator = QueryConditionOperator = {}));
+var QueryLogicalOperator;
+(function (QueryLogicalOperator) {
+    QueryLogicalOperator["AND"] = "AND";
+    QueryLogicalOperator["OR"] = "OR";
+})(QueryLogicalOperator || (exports.QueryLogicalOperator = QueryLogicalOperator = {}));
+var QueryOrderDirection;
+(function (QueryOrderDirection) {
+    QueryOrderDirection["ASC"] = "asc";
+    QueryOrderDirection["DESC"] = "desc";
+})(QueryOrderDirection || (exports.QueryOrderDirection = QueryOrderDirection = {}));
+class CosmosDbQueryBuilder {
+    constructor() {
+        this.parameters = {};
+        this.isCountQuery = false;
+        this.query = {
+            conditions: [],
+            groupedConditions: [],
+            customConditions: [],
+        };
+    }
+    where(field, value, operator, logicalOperator = QueryLogicalOperator.AND) {
+        this.query.conditions.push({ field, value, operator, logicalOperator });
+        return this;
+    }
+    whereCustom(condition, logicalOperator = QueryLogicalOperator.AND, parameters = {}) {
+        if (!this.query.customConditions) {
+            this.query.customConditions = [];
+        }
+        this.query.customConditions.push({
+            condition,
+            logicalOperator,
+            parameters,
+        });
+        return this;
+    }
+    whereRange(field, lower, upper, logicalOperator = QueryLogicalOperator.AND) {
+        field = field.replace('Range', '');
+        this.query.conditions.push({
+            field,
+            value: lower,
+            operator: QueryConditionOperator.GREATER_THAN_OR_EQUAL,
+            logicalOperator,
+        });
+        this.query.conditions.push({
+            field,
+            value: upper,
+            operator: QueryConditionOperator.LESS_THAN_OR_EQUAL,
+            logicalOperator,
+        });
+        return this;
+    }
+    whereGroup(conditions, logicalOperator = QueryLogicalOperator.AND) {
+        this.query.groupedConditions = this.query.groupedConditions || [];
+        this.query.groupedConditions.push({ conditions, logicalOperator });
+        return this;
+    }
+    orderBy(field, direction) {
+        this.query.orderBy = { field, direction };
+        return this;
+    }
+    setOffset(offset) {
+        this.query.skip = offset;
+        return this;
+    }
+    setLimit(limit) {
+        // if (limit > 100) {
+        //   throw new Error('Limit cannot be greater than 100');
+        // }
+        // think about how to handle this to protect external calls
+        // at the same time allow internal calls to have higher limits
+        this.query.top = limit;
+        return this;
+    }
+    selectFields(fields) {
+        this.query.selectFields = fields;
+        return this;
+    }
+    count() {
+        this.isCountQuery = true;
+        return this;
+    }
+    buildSqlQuery(applyPagination = true) {
+        let sqlQuery = 'SELECT * FROM c';
+        let paramIndex = 0;
+        if (this.isCountQuery) {
+            sqlQuery = 'SELECT VALUE COUNT(1) FROM c';
+        }
+        else if (this.query.selectFields) {
+            const dynamicProjection = this.buildCustomProjection(this.query.selectFields);
+            sqlQuery = sqlQuery.replace('SELECT *', `SELECT VALUE ${dynamicProjection}`);
+        }
+        if (this.query.conditions.length > 0) {
+            sqlQuery += ' WHERE';
+            for (const condition of this.query.conditions) {
+                // 'from' is a reserved word in Cosmos DB, so we need to use bracket notation
+                if (condition.field === 'from') {
+                    condition.field = `['from']`;
+                }
+                // we use IN operator for arrays and = for single values
+                if (condition.operator === QueryConditionOperator.IN) {
+                    // If the value is an array with a single element, use the equal operator
+                    if (Array.isArray(condition.value) && condition.value.length === 1) {
+                        sqlQuery += ` c.${condition.field} = @p${paramIndex}`;
+                    }
+                    else {
+                        sqlQuery += ` ARRAY_CONTAINS(@p${paramIndex}, c.${condition.field})`;
+                    }
+                }
+                else if (condition.operator === QueryConditionOperator.NOT_IN) {
+                    // If the value is an array with a single element, use the not equal operator
+                    if (Array.isArray(condition.value) && condition.value.length === 1) {
+                        sqlQuery += ` c.${condition.field} != @p${paramIndex}`;
+                    }
+                    else {
+                        sqlQuery += ` NOT ARRAY_CONTAINS(@p${paramIndex}, c.${condition.field})`;
+                    }
+                }
+                else {
+                    sqlQuery += ` c.${condition.field} ${this.getSqlOperator(condition.operator)} @p${paramIndex}`;
+                }
+                if (condition !== this.query.conditions[this.query.conditions.length - 1]) {
+                    sqlQuery += ` ${condition.logicalOperator}`;
+                }
+                // If the value is an array with a single element, use the equal operator
+                if (Array.isArray(condition.value) && condition.value.length === 1) {
+                    this.parameters[`@p${paramIndex}`] = condition.value[0];
+                }
+                else {
+                    this.parameters[`@p${paramIndex}`] = condition.value;
+                }
+                paramIndex++;
+            }
+        }
+        if (this.query.groupedConditions &&
+            this.query.groupedConditions.length > 0) {
+            let groupedConditionsSql = '';
+            for (const groupedCondition of this.query.groupedConditions) {
+                let groupSql = '';
+                for (const condition of groupedCondition.conditions) {
+                    if (condition.operator === QueryConditionOperator.IN) {
+                        groupSql += ` ARRAY_CONTAINS(@p${paramIndex}, c.${condition.field})`;
+                    }
+                    else {
+                        groupSql += ` c.${condition.field} ${this.getSqlOperator(condition.operator)} @p${paramIndex} `;
+                    }
+                    if (condition !==
+                        groupedCondition.conditions[groupedCondition.conditions.length - 1]) {
+                        groupSql += ` ${condition.logicalOperator}`;
+                    }
+                    this.parameters[`@p${paramIndex}`] = condition.value;
+                    paramIndex++;
+                }
+                groupedConditionsSql += ` (${groupSql})`;
+                if (groupedCondition !==
+                    this.query.groupedConditions[this.query.groupedConditions.length - 1]) {
+                    groupedConditionsSql += ` ${groupedCondition.logicalOperator}`;
+                }
+            }
+            if (groupedConditionsSql !== '') {
+                sqlQuery += ` AND${groupedConditionsSql}`;
+            }
+        }
+        if (this.query.customConditions) {
+            // If there are already conditions in the query, add an AND operator
+            if (this.query.conditions.length > 0 ||
+                (this.query.groupedConditions &&
+                    this.query.groupedConditions.length > 0)) {
+                sqlQuery += ' AND';
+            }
+            else {
+                sqlQuery += ' WHERE';
+            }
+            for (const customCondition of this.query.customConditions) {
+                sqlQuery += ` ${customCondition.condition}`;
+                // If this isn't the last custom condition, add the logical operator
+                if (customCondition !==
+                    this.query.customConditions[this.query.customConditions.length - 1]) {
+                    sqlQuery += ` ${customCondition.logicalOperator}`;
+                }
+                // Add the custom condition's parameters to this.parameters
+                if (customCondition.parameters) {
+                    for (const [key, value] of Object.entries(customCondition.parameters)) {
+                        this.parameters[key] = value;
+                    }
+                }
+            }
+        }
+        if (this.query.orderBy) {
+            sqlQuery += ` ORDER BY c.${this.query.orderBy.field} ${this.query.orderBy.direction}`;
+        }
+        // Default values
+        const defaultOffset = 0;
+        const defaultLimit = 25;
+        if (this.query.skip !== undefined || this.query.top !== undefined) {
+            const offset = this.query.skip !== undefined ? this.query.skip : defaultOffset;
+            const limit = this.query.top !== undefined ? this.query.top : defaultLimit;
+            if (applyPagination) {
+                sqlQuery += ` OFFSET ${offset} LIMIT ${limit}`;
+            }
+        }
+        const parameters = Object.entries(this.parameters).map(([name, value]) => ({ name, value }));
+        sqlQuery = sqlQuery.replace(/\.\[/g, '[');
+        return { query: sqlQuery, parameters };
+    }
+    buildCustomProjection(selectClauses) {
+        const result = {};
+        for (const str of selectClauses) {
+            const parts = str.split('.');
+            let currentObject = result;
+            for (let i = 0; i < parts.length; i++) {
+                const part = parts[i];
+                if (i === parts.length - 1) {
+                    // If it's the last part, it's a property with the modified value
+                    currentObject[part] = 'c.' + str;
+                }
+                else {
+                    // If it's not the last part, create an object if it doesn't exist
+                    if (!currentObject[part] || typeof currentObject[part] !== 'object') {
+                        currentObject[part] = {};
+                    }
+                    currentObject = currentObject[part];
+                }
+            }
+        }
+        return JSON.stringify(result).replace(/"/g, '');
+    }
+    getSqlOperator(operator) {
+        switch (operator) {
+            case QueryConditionOperator.EQUAL:
+                return '=';
+            case QueryConditionOperator.NOT_EQUAL:
+                return '!=';
+            case QueryConditionOperator.GREATER_THAN:
+                return '>';
+            case QueryConditionOperator.LESS_THAN:
+                return '<';
+            case QueryConditionOperator.GREATER_THAN_OR_EQUAL:
+                return '>=';
+            case QueryConditionOperator.LESS_THAN_OR_EQUAL:
+                return '<=';
+            case QueryConditionOperator.IN:
+                return 'IN';
+            case QueryConditionOperator.NOT_IN:
+                return 'NOT IN';
+            default:
+                throw new Error(`Unsupported operator: ${operator}`);
+        }
+    }
+    fromFilter(filter) {
+        const defaultMin = 0;
+        const defaultMax = Number.MAX_SAFE_INTEGER;
+        const handleFilter = (key, value) => {
+            if (Array.isArray(value) && value.length > 0) {
+                // check if the array is a RangeFilter
+                // check with endsWith to support nested properties
+                if (key.endsWith('range')) {
+                    for (const rangeFilter of value) {
+                        const min = rangeFilter.min !== undefined ? rangeFilter.min : defaultMin;
+                        const max = rangeFilter.max !== undefined ? rangeFilter.max : defaultMax;
+                        // check if the range filter is nested
+                        // if it is, replace the field with the nested field
+                        if (key.endsWith('.range')) {
+                            rangeFilter.field = key.replace('.range', `.${rangeFilter.field}`);
+                        }
+                        this.whereRange(rangeFilter.field, min, max);
+                    }
+                }
+                else if (key.endsWith('attributes')) {
+                    let traitLogicalOperator = QueryLogicalOperator.AND;
+                    if (key === 'attributes') {
+                        traitLogicalOperator = QueryLogicalOperator.OR;
+                    }
+                    const { filterString, parameters } = this.getAttributesQueryAndParams(key, value, traitLogicalOperator);
+                    this.whereCustom(filterString, QueryLogicalOperator.AND, parameters);
+                }
+                else if (key === 'activityAddress') {
+                    // // used for nft activity to filter by from or to
+                    if (value.length > 1) {
+                        this.whereCustom(`(ARRAY_CONTAINS(@activityAddress, c.to) OR ARRAY_CONTAINS(@activityAddress, c['from']))`, QueryLogicalOperator.AND, { '@activityAddress': value });
+                    }
+                    else {
+                        this.whereCustom(`(c.to = @activityAddress OR c['from'] = @activityAddress)`, QueryLogicalOperator.AND, { '@activityAddress': value[0] });
+                    }
+                }
+                else if (key === 'mintToken') {
+                    // used for mint profile to filter specific mint tokens
+                    const { filterString, parameters } = this.getMintProfilePricesQueryAndParams(value);
+                    this.whereCustom(filterString, QueryLogicalOperator.AND, parameters);
+                }
+                else {
+                    this.where(key, value, QueryConditionOperator.IN);
+                }
+            }
+            else if (typeof value === 'boolean' ||
+                typeof value === 'string' ||
+                typeof value === 'number') {
+                // handle special filter cases
+                switch (key) {
+                    // filter for collection offers docs
+                    case 'withAttributes':
+                        if (value === true) {
+                            this.whereCustom('ARRAY_LENGTH(c.attributes) > 0');
+                        }
+                        else {
+                            this.whereCustom('ARRAY_LENGTH(c.attributes) = 0');
+                        }
+                        break;
+                    // filter for nft docs
+                    case 'activeAuction':
+                        if (value === true) {
+                            this.whereCustom(`(c.saleInfo.deadline = 0 OR c.saleInfo.deadline > ${Math.floor(Date.now() / 1000)})`);
+                        }
+                        else {
+                            this.whereCustom(`(c.saleInfo.deadline != 0 AND c.saleInfo.deadline <= ${Math.floor(Date.now() / 1000)})`);
+                        }
+                        break;
+                    // special case to filter out SFTs that are on sale(as duplicates of the original SFTs)
+                    case 'sftOriginalDoc':
+                        if (value === true) {
+                            this.whereCustom(`(c.type = '${enums_1.EsdtTokenType.NonFungibleESDT}' OR (c.cp_staked = false AND c.onSale = false AND (c.type = '${enums_1.EsdtTokenType.SemiFungibleESDT}' OR c.type = '${enums_1.EsdtTokenType.MetaESDT}')))`);
+                        }
+                        break;
+                    // filter for mint profile docs
+                    case 'activeMint':
+                        if (value === true) {
+                            this.whereCustom(`(c.endTime = 0 OR c.endTime > ${Math.floor(Date.now() / 1000)})`);
+                        }
+                        else {
+                            this.whereCustom(`(c.endTime != 0 AND c.endTime <= ${Math.floor(Date.now() / 1000)})`);
+                        }
+                        break;
+                    // special case to filter out markets that have debt ceiling reached
+                    case 'isDebtCeilingReached':
+                        if (value === true) {
+                            this.whereCustom(`(c.debtCeilingShort >= c.maxDebtUsdShort)`);
+                        }
+                        else if (value === false) {
+                            this.whereCustom(`(c.debtCeilingShort < c.maxDebtUsdShort)`);
+                        }
+                        break;
+                    default:
+                        this.where(key, value, QueryConditionOperator.EQUAL);
+                        break;
+                }
+            }
+            else if (typeof value === 'object' && value !== null) {
+                // Handle nested properties
+                for (const [nestedKey, nestedValue] of Object.entries(value)) {
+                    handleFilter(`${key}.${nestedKey}`, nestedValue);
+                }
+            }
+        };
+        for (const [key, value] of Object.entries(filter.filters)) {
+            handleFilter(key, value);
+        }
+        if (filter.includeCount === true) {
+            this.count();
+        }
+        else {
+            if (filter.select && filter.select.length > 0) {
+                this.selectFields(filter.select);
+            }
+            if (filter.orderBy && filter.orderBy.length > 0) {
+                for (const order of filter.orderBy) {
+                    const [field, direction] = order.split(' ');
+                    this.orderBy(field, direction);
+                }
+            }
+            this.setOffset(filter.skip ?? 0);
+            this.setLimit(filter.top ?? 25);
+        }
+        return this;
+    }
+    getMintProfilePricesQueryAndParams(mintToken) {
+        const pricesFilter = [];
+        const parameters = {};
+        mintToken.forEach((token, index) => {
+            pricesFilter.push(`ARRAY_CONTAINS(c.prices, ({'tokenIdentifier': @tokenIdentifier${index}}), true)`);
+            parameters[`@tokenIdentifier${index}`] = token;
+        });
+        const filterString = `(${pricesFilter.join(' OR ')})`;
+        return { filterString, parameters };
+    }
+    getAttributesQueryAndParams(key, attributes, traitLogicalOperator = QueryLogicalOperator.AND) {
+        const groupedByTrait = this.groupAttributesByTrait(attributes);
+        const attributesFilters = [];
+        const parameters = {};
+        groupedByTrait.forEach((pair, traitIndex) => {
+            const { trait_type, values } = pair;
+            const valuesFilter = [];
+            values.forEach((value, valueIndex) => {
+                valuesFilter.push(`ARRAY_CONTAINS(c.${key}, ({'trait_type': @trait${traitIndex}, 'value': @trait${traitIndex}value${valueIndex}}), true)`);
+                parameters[`@trait${traitIndex}`] = trait_type;
+                parameters[`@trait${traitIndex}value${valueIndex}`] = value;
+            });
+            attributesFilters.push(`(${valuesFilter.join(' OR ')})`);
+        });
+        const filterString = `(${attributesFilters.join(` ${traitLogicalOperator} `)})`;
+        return { filterString, parameters };
+    }
+    groupAttributesByTrait(attributes) {
+        return attributes.reduce((accumulator, current) => {
+            // Find the index of the object with the same trait_type
+            const index = accumulator.findIndex((item) => item.trait_type === current.trait_type);
+            if (index >= 0) {
+                // If found, append the current value to the values array of the found object
+                accumulator[index].values.push(current.value);
+            }
+            else {
+                // If not found, create a new object and add it to the accumulator
+                accumulator.push({
+                    trait_type: current.trait_type,
+                    values: [current.value],
+                });
+            }
+            return accumulator;
+        }, []);
+    }
+}
+exports.CosmosDbQueryBuilder = CosmosDbQueryBuilder;

package/dist/cosmos-db/documents/activity/chain-activity.enum.d.ts

@@ -0,0 +1,4 @@
+export declare enum ActivityChain {
+    MULTIVERSX = "MVX",
+    SUI = "SUI"
+}

package/dist/cosmos-db/documents/activity/chain-activity.enum.js

@@ -0,0 +1,5 @@
+export var ActivityChain;
+(function (ActivityChain) {
+    ActivityChain["MULTIVERSX"] = "MVX";
+    ActivityChain["SUI"] = "SUI";
+})(ActivityChain || (ActivityChain = {}));

package/dist/cosmos-db/documents/activity/event-source.enum.d.ts

@@ -0,0 +1,15 @@
+export declare enum NftActivityEventSource {
+    MVX_BUILT_IN = "mvxBuiltIn",
+    XOXNO_MARKETPLACE = "xoxno",
+    FRAMEIT_MARKETPLACE = "frameit",
+    DEADRARE_MARKETPLACE = "deadrare",
+    KROGAN_MARKETPLACE = "krogan",
+    XOXNO_LAUNCHPAD = "xoxnoLaunchpad",
+    XOXNO_STAKING = "xoxnoStaking",
+    XOXNO_P2P = "xoxnoP2P",
+    XOXNO_LS = "xoxnoLs",
+    XOXNO_EGLD_LS = "xoxnoEgldLs",
+    XOXNO_LENDING = "xoxnoLending",
+    BOBER_BATTLE = "boberBattle",
+    BOBER_WHEEL = "boberWheel"
+}

package/dist/cosmos-db/documents/activity/event-source.enum.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NftActivityEventSource = void 0;
+var NftActivityEventSource;
+(function (NftActivityEventSource) {
+    NftActivityEventSource["MVX_BUILT_IN"] = "mvxBuiltIn";
+    NftActivityEventSource["XOXNO_MARKETPLACE"] = "xoxno";
+    NftActivityEventSource["FRAMEIT_MARKETPLACE"] = "frameit";
+    NftActivityEventSource["DEADRARE_MARKETPLACE"] = "deadrare";
+    NftActivityEventSource["KROGAN_MARKETPLACE"] = "krogan";
+    NftActivityEventSource["XOXNO_LAUNCHPAD"] = "xoxnoLaunchpad";
+    NftActivityEventSource["XOXNO_STAKING"] = "xoxnoStaking";
+    NftActivityEventSource["XOXNO_P2P"] = "xoxnoP2P";
+    NftActivityEventSource["XOXNO_LS"] = "xoxnoLs";
+    NftActivityEventSource["XOXNO_EGLD_LS"] = "xoxnoEgldLs";
+    NftActivityEventSource["XOXNO_LENDING"] = "xoxnoLending";
+    NftActivityEventSource["BOBER_BATTLE"] = "boberBattle";
+    NftActivityEventSource["BOBER_WHEEL"] = "boberWheel";
+})(NftActivityEventSource || (exports.NftActivityEventSource = NftActivityEventSource = {}));

package/dist/cosmos-db/documents/activity/nft-activity-data.d.ts

@@ -0,0 +1,22 @@
+import { NftDoc } from '../token/nft-details.doc';
+export interface NftActivityData {
+    collection: string;
+    identifier?: string;
+    price: number;
+    paymentToken: string;
+    quantity: number;
+    scId: number;
+    usdValue: number;
+    egldValue: number;
+    auctionType?: string;
+    deadline?: number;
+    originalPayment?: {
+        paymentToken: string;
+        price: number;
+    };
+    nftInfo?: Partial<NftDoc>;
+}
+export interface NftMvxBuiltIn {
+    collection: string;
+    identifier: string;
+}

package/dist/cosmos-db/documents/activity/nft-activity-data.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cosmos-db/documents/activity/nft-activity-type.enum.d.ts

@@ -0,0 +1,28 @@
+export declare enum NftActivityType {
+    NFT_CREATE = "nftCreate",
+    NFT_BURN = "nftBurn",
+    NFT_UPDATE = "nftUpdate",
+    NFT_TRANSFER = "nftTransfer",
+    LISTING_CREATE = "listingCreate",
+    LISTING_WITHDRAW = "listingWithdraw",
+    LISTING_UPDATE = "listingUpdate",
+    AUCTION_BID = "auctionBid",
+    AUCTION_OUT_BID = "auctionOutBid",
+    OFFER_CREATE = "offerCreate",
+    OFFER_WITHDRAW = "offerWithdraw",
+    OFFER_REJECT = "offerReject",
+    GLOBAL_OFFER_CREATE = "globalOfferCreate",
+    GLOBAL_OFFER_WITHDRAW = "globalOfferWithdraw",
+    TRADE = "trade",
+    BULK_TRADE = "bulkTrade",
+    AUCTION_TRADE = "auctionTrade",
+    OTHER_TRADE = "otherTrade",// fiat or binance buy
+    OFFER_TRADE = "offerTrade",
+    GLOBAL_OFFER_TRADE = "globalOfferTrade",
+    STAKE = "stake",
+    UN_STAKE = "unStake",
+    CREATE_GAME = "createGame",
+    JOIN_GAME = "joinGame",
+    CANCEL_GAME = "cancelGame",
+    END_GAME = "endGame"
+}

package/dist/cosmos-db/documents/activity/nft-activity-type.enum.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NftActivityType = void 0;
+var NftActivityType;
+(function (NftActivityType) {
+    // MVX Built-in
+    NftActivityType["NFT_CREATE"] = "nftCreate";
+    NftActivityType["NFT_BURN"] = "nftBurn";
+    NftActivityType["NFT_UPDATE"] = "nftUpdate";
+    NftActivityType["NFT_TRANSFER"] = "nftTransfer";
+    // Marketplace
+    NftActivityType["LISTING_CREATE"] = "listingCreate";
+    NftActivityType["LISTING_WITHDRAW"] = "listingWithdraw";
+    NftActivityType["LISTING_UPDATE"] = "listingUpdate";
+    NftActivityType["AUCTION_BID"] = "auctionBid";
+    NftActivityType["AUCTION_OUT_BID"] = "auctionOutBid";
+    NftActivityType["OFFER_CREATE"] = "offerCreate";
+    NftActivityType["OFFER_WITHDRAW"] = "offerWithdraw";
+    NftActivityType["OFFER_REJECT"] = "offerReject";
+    NftActivityType["GLOBAL_OFFER_CREATE"] = "globalOfferCreate";
+    NftActivityType["GLOBAL_OFFER_WITHDRAW"] = "globalOfferWithdraw";
+    NftActivityType["TRADE"] = "trade";
+    NftActivityType["BULK_TRADE"] = "bulkTrade";
+    NftActivityType["AUCTION_TRADE"] = "auctionTrade";
+    NftActivityType["OTHER_TRADE"] = "otherTrade";
+    NftActivityType["OFFER_TRADE"] = "offerTrade";
+    NftActivityType["GLOBAL_OFFER_TRADE"] = "globalOfferTrade";
+    // Staking
+    NftActivityType["STAKE"] = "stake";
+    NftActivityType["UN_STAKE"] = "unStake";
+    // Coin Flip Games
+    NftActivityType["CREATE_GAME"] = "createGame";
+    NftActivityType["JOIN_GAME"] = "joinGame";
+    NftActivityType["CANCEL_GAME"] = "cancelGame";
+    NftActivityType["END_GAME"] = "endGame";
+})(NftActivityType || (exports.NftActivityType = NftActivityType = {}));