@microcosmmoney/auth-core 1.0.1 → 1.0.3

package/dist/api-client.d.ts

@@ -5,5 +5,6 @@ export declare class ApiClient {
     fetch<T>(path: string, options?: RequestInit): Promise<T>;
     get<T>(path: string): Promise<T>;
     post<T>(path: string, body: unknown): Promise<T>;
+    put<T>(path: string, body: unknown): Promise<T>;
     patch<T>(path: string, body: unknown): Promise<T>;
 }

package/dist/api-client.js

@@ -47,6 +47,12 @@ class ApiClient {
             body: JSON.stringify(body),
         });
     }
+    async put(path, body) {
+        return this.fetch(path, {
+            method: 'PUT',
+            body: JSON.stringify(body),
+        });
+    }
     async patch(path, body) {
         return this.fetch(path, {
             method: 'PATCH',

package/dist/index.d.ts

@@ -4,4 +4,4 @@ export { Storage, STORAGE_KEYS } from './storage';
 export { ApiClient } from './api-client';
 export { MicrocosmAPI } from './open-api';
 export type { MicrocosmAPIConfig } from './open-api';
-export type { MicrocosmAuthConfig, ResolvedConfig, User, TokenData, AuthState, LoginOptions, TokenExchangeResponse, UserProfileResponse, ApiResponse, MCDBalance, MCCBalance, MCCPrice, } from './types';
+export type { MicrocosmAuthConfig, ResolvedConfig, User, TokenData, AuthState, LoginOptions, TokenExchangeResponse, UserProfileResponse, ApiResponse, MCDBalance, MCCBalance, MCCPrice, Wallet, TokenPortfolio, MCCLock, MiningRatio, MiningDistribution, BuybackQuote, BuybackRecord, Territory, TerritorySummary, TerritoryStats, TerritoryMember, Proposal, ProposalDetail, VoteResult, VotePower, AuctionBid, MCDTransaction, MCDReward, MiningRequest, MiningConfirmData, MiningRequestResult, MiningConfig, BuybackRecordInput, ReincarnationConfig, MCCHistoryRecord, CycleHistory, AuctionHistory, } from './types';

package/dist/open-api.d.ts

@@ -13,23 +13,98 @@ export declare class MicrocosmAPI {
         getPrice: () => Promise<ApiRes<any>>;
         getStats: () => Promise<ApiRes<any>>;
         getBalance: (token: string) => Promise<ApiRes<any>>;
+        getBalanceByAddress: (address: string) => Promise<ApiRes<any>>;
+        getLocks: (token: string) => Promise<ApiRes<any>>;
+        getTransactions: (token: string, params?: {
+            page?: number;
+            page_size?: number;
+        }) => Promise<ApiRes<any>>;
+        getHistory: (token: string, params?: {
+            tx_type?: string;
+            page?: number;
+            page_size?: number;
+        }) => Promise<ApiRes<any>>;
         getHolders: () => Promise<ApiRes<any>>;
         getMiningHistory: (days?: number) => Promise<ApiRes<any>>;
     };
     readonly mcd: {
         getBalance: (token: string) => Promise<ApiRes<any>>;
         getStats: () => Promise<ApiRes<any>>;
+        getTransactions: (token: string, params?: {
+            page?: number;
+            page_size?: number;
+            type?: string;
+        }) => Promise<ApiRes<any>>;
+        getRewards: (token: string, params?: {
+            page?: number;
+            page_size?: number;
+            start_date?: string;
+            end_date?: string;
+        }) => Promise<ApiRes<any>>;
+    };
+    readonly wallets: {
+        list: (token: string) => Promise<ApiRes<any>>;
+        getTokens: (address: string) => Promise<ApiRes<any>>;
     };
     readonly reincarnation: {
         getPool: () => Promise<ApiRes<any>>;
         getBuybackPrice: () => Promise<ApiRes<any>>;
+        getQuote: (mccAmount: number) => Promise<ApiRes<any>>;
+        getUserHistory: (token: string, params?: {
+            page?: number;
+            page_size?: number;
+        }) => Promise<ApiRes<any>>;
+        record: (token: string, data: {
+            tx_signature: string;
+            wallet_address: string;
+            mcc_amount: number;
+            usdc_amount: number;
+            stablecoin?: string;
+        }) => Promise<ApiRes<any>>;
+        getConfig: () => Promise<ApiRes<any>>;
+        getCycleHistory: (params?: {
+            page?: number;
+            page_size?: number;
+        }) => Promise<ApiRes<any>>;
     };
     readonly mining: {
         getRecords: (token: string, params?: {
+            page?: number;
+            page_size?: number;
+        }) => Promise<ApiRes<any>>;
+        getStats: (token: string) => Promise<ApiRes<any>>;
+        getGlobalStats: () => Promise<ApiRes<any>>;
+        getRatio: () => Promise<ApiRes<any>>;
+        getDistribution: (token: string, params?: {
+            page?: number;
+            page_size?: number;
+        }) => Promise<ApiRes<any>>;
+        createRequest: (token: string, data: {
+            mcc_amount: number;
+            stablecoin?: string;
+            wallet_address: string;
+        }) => Promise<ApiRes<any>>;
+        confirm: (token: string, data: {
+            request_id: string;
+            tx_signature: string;
+            mcc_amount: number;
+            usdc_amount: number;
+            stablecoin_type?: string;
+        }) => Promise<ApiRes<any>>;
+        publicRequest: (data: {
+            wallet_address: string;
+            mcc_amount: number;
+            stablecoin?: string;
+        }) => Promise<ApiRes<any>>;
+        publicVerify: (data: {
+            request_id: string;
+            tx_signature: string;
+        }) => Promise<ApiRes<any>>;
+        getHistory: (token: string, params?: {
             limit?: number;
             offset?: number;
         }) => Promise<ApiRes<any>>;
-        getStats: (token: string) => Promise<ApiRes<any>>;
+        getConfig: () => Promise<ApiRes<any>>;
     };
     readonly users: {
         getProfile: (token: string) => Promise<ApiRes<any>>;
@@ -39,17 +114,76 @@ export declare class MicrocosmAPI {
         getMarket: () => Promise<ApiRes<any>>;
         getPlatform: () => Promise<ApiRes<any>>;
         getUserSummary: (wallet: string) => Promise<ApiRes<any>>;
+        getUserStats: () => Promise<ApiRes<any>>;
+        getTerritoryStats: () => Promise<ApiRes<any>>;
+        getMiningHistory: (days?: number) => Promise<ApiRes<any>>;
+    };
+    readonly territories: {
+        list: (token: string, params?: {
+            unit_type?: string;
+            parent_id?: string;
+            page?: number;
+            page_size?: number;
+        }) => Promise<ApiRes<any>>;
+        getSummary: (token: string) => Promise<ApiRes<any>>;
+        getDetail: (token: string, id: string) => Promise<ApiRes<any>>;
+        getStats: (token: string, id: string) => Promise<ApiRes<any>>;
+        getMembers: (token: string, id: string, params?: {
+            page?: number;
+            page_size?: number;
+        }) => Promise<ApiRes<any>>;
+        getIncomeChart: (token: string, id: string, period?: string) => Promise<ApiRes<any>>;
+        getKpiHistory: (token: string, id: string) => Promise<ApiRes<any>>;
+        getMemberRanking: (token: string, id: string, params?: {
+            page?: number;
+            page_size?: number;
+        }) => Promise<ApiRes<any>>;
+        update: (token: string, id: string, data: {
+            unit_name?: string;
+            description?: string;
+            image_url?: string;
+        }) => Promise<ApiRes<any>>;
+        updateName: (token: string, id: string, name: string, force?: boolean) => Promise<ApiRes<any>>;
     };
     readonly territory: {
         getCollection: () => Promise<ApiRes<any>>;
         getNft: (mint: string) => Promise<ApiRes<any>>;
         getUserNfts: (wallet: string) => Promise<ApiRes<any>>;
     };
+    readonly voting: {
+        getProposals: (token: string, params?: {
+            status?: string;
+            page?: number;
+            page_size?: number;
+        }) => Promise<ApiRes<any>>;
+        getDetail: (token: string, id: string) => Promise<ApiRes<any>>;
+        getPower: (token: string) => Promise<ApiRes<any>>;
+        createProposal: (token: string, data: {
+            title: string;
+            description: string;
+            proposal_type?: string;
+            voting_hours?: number;
+            options: string[];
+        }) => Promise<ApiRes<any>>;
+        castVote: (token: string, proposalId: string, data: {
+            option_index: number;
+            vote_count?: number;
+        }) => Promise<ApiRes<any>>;
+    };
     readonly auctions: {
         getConfig: () => Promise<ApiRes<any>>;
         getActive: () => Promise<ApiRes<any>>;
         getDetails: (id: number) => Promise<ApiRes<any>>;
         getBids: (id: number) => Promise<ApiRes<any>>;
+        getUserBids: (wallet: string) => Promise<ApiRes<any>>;
+        getUserAuctions: (wallet: string) => Promise<ApiRes<any>>;
+        getMyBids: (token: string) => Promise<ApiRes<any>>;
+        placeBid: (token: string, auctionId: number, bidAmount: number) => Promise<ApiRes<any>>;
+        prepareCancelBid: (token: string, auctionId: number) => Promise<ApiRes<any>>;
+        getHistory: (params?: {
+            page?: number;
+            page_size?: number;
+        }) => Promise<ApiRes<any>>;
     };
     readonly techTree: {
         getConfig: () => Promise<ApiRes<any>>;

package/dist/open-api.js

@@ -18,7 +18,7 @@ async function request(baseUrl, path, token) {
         throw new Error(data.detail || `API error ${res.status}`);
     return data;
 }
-async function postRequest(baseUrl, path, body, token) {
+async function mutateRequest(baseUrl, method, path, body, token) {
     const headers = {
         'Accept': 'application/json',
         'Content-Type': 'application/json',
@@ -26,7 +26,7 @@ async function postRequest(baseUrl, path, body, token) {
     if (token)
         headers['Authorization'] = `Bearer ${token}`;
     const res = await fetch(`${baseUrl}${path}`, {
-        method: 'POST',
+        method,
         headers,
         body: JSON.stringify(body),
     });
@@ -35,29 +35,94 @@ async function postRequest(baseUrl, path, body, token) {
         throw new Error(data.detail || `API error ${res.status}`);
     return data;
 }
+async function postRequest(baseUrl, path, body, token) {
+    return mutateRequest(baseUrl, 'POST', path, body, token);
+}
+async function putRequest(baseUrl, path, body, token) {
+    return mutateRequest(baseUrl, 'PUT', path, body, token);
+}
 class MicrocosmAPI {
     constructor(config) {
         this.mcc = {
             getPrice: () => request(this.base, '/mcc/price'),
             getStats: () => request(this.base, '/mcc/stats'),
             getBalance: (token) => request(this.base, '/mcc/balance', token),
+            getBalanceByAddress: (address) => request(this.base, `/mcc/balance/${address}`),
+            getLocks: (token) => request(this.base, '/mcc/locks', token),
+            getTransactions: (token, params) => {
+                const p = params || {};
+                return request(this.base, `/mcc/transactions?page=${p.page || 1}&page_size=${p.page_size || 20}`, token);
+            },
+            getHistory: (token, params) => {
+                const p = params || {};
+                let qs = `?page=${p.page || 1}&page_size=${p.page_size || 20}`;
+                if (p.tx_type)
+                    qs += `&tx_type=${p.tx_type}`;
+                return request(this.base, `/mcc/history${qs}`, token);
+            },
             getHolders: () => request(this.base, '/reincarnation/holders'),
             getMiningHistory: (days = 30) => request(this.base, `/reincarnation/mining-history?days=${days}`),
         };
         this.mcd = {
             getBalance: (token) => request(this.base, '/mcd/balance', token),
             getStats: () => request(this.base, '/mcd/stats'),
+            getTransactions: (token, params) => {
+                const p = params || {};
+                let qs = `?page=${p.page || 1}&page_size=${p.page_size || 20}`;
+                if (p.type)
+                    qs += `&type=${p.type}`;
+                return request(this.base, `/mcd/transactions${qs}`, token);
+            },
+            getRewards: (token, params) => {
+                const p = params || {};
+                let qs = `?page=${p.page || 1}&page_size=${p.page_size || 20}`;
+                if (p.start_date)
+                    qs += `&start_date=${p.start_date}`;
+                if (p.end_date)
+                    qs += `&end_date=${p.end_date}`;
+                return request(this.base, `/mcd/rewards${qs}`, token);
+            },
+        };
+        this.wallets = {
+            list: (token) => request(this.base, '/wallets', token),
+            getTokens: (address) => request(this.base, `/wallets/${address}/tokens`),
         };
         this.reincarnation = {
             getPool: () => request(this.base, '/reincarnation/pool'),
             getBuybackPrice: () => request(this.base, '/reincarnation/buyback-price'),
+            getQuote: (mccAmount) => postRequest(this.base, '/reincarnation/quote', { mcc_amount: mccAmount }),
+            getUserHistory: (token, params) => {
+                const p = params || {};
+                return request(this.base, `/reincarnation/user-history?page=${p.page || 1}&page_size=${p.page_size || 20}`, token);
+            },
+            record: (token, data) => postRequest(this.base, '/reincarnation/record', data, token),
+            getConfig: () => request(this.base, '/reincarnation/config'),
+            getCycleHistory: (params) => {
+                const p = params || {};
+                return request(this.base, `/reincarnation/cycle-history?page=${p.page || 1}&page_size=${p.page_size || 20}`);
+            },
         };
         this.mining = {
             getRecords: (token, params) => {
-                const qs = params ? `?limit=${params.limit || 20}&offset=${params.offset || 0}` : '';
-                return request(this.base, `/mining/records${qs}`, token);
+                const p = params || {};
+                return request(this.base, `/mining/records?page=${p.page || 1}&page_size=${p.page_size || 20}`, token);
             },
             getStats: (token) => request(this.base, '/mining/stats', token),
+            getGlobalStats: () => request(this.base, '/mining/global-stats'),
+            getRatio: () => request(this.base, '/mining/ratio'),
+            getDistribution: (token, params) => {
+                const p = params || {};
+                return request(this.base, `/mining/distribution?page=${p.page || 1}&page_size=${p.page_size || 20}`, token);
+            },
+            createRequest: (token, data) => postRequest(this.base, '/mining/request', data, token),
+            confirm: (token, data) => postRequest(this.base, '/mining/confirm', data, token),
+            publicRequest: (data) => postRequest(this.base, '/mining/public/request', data),
+            publicVerify: (data) => postRequest(this.base, '/mining/public/verify', data),
+            getHistory: (token, params) => {
+                const p = params || {};
+                return request(this.base, `/mining/history?limit=${p.limit || 20}&offset=${p.offset || 0}`, token);
+            },
+            getConfig: () => request(this.base, '/mining/config'),
         };
         this.users = {
             getProfile: (token) => request(this.base, '/users/me', token),
@@ -67,17 +132,68 @@ class MicrocosmAPI {
             getMarket: () => request(this.base, '/dashboard/market'),
             getPlatform: () => request(this.base, '/dashboard/platform'),
             getUserSummary: (wallet) => request(this.base, `/dashboard/user/${wallet}`),
+            getUserStats: () => request(this.base, '/dashboard/stats/users'),
+            getTerritoryStats: () => request(this.base, '/dashboard/stats/territories'),
+            getMiningHistory: (days = 30) => request(this.base, `/dashboard/stats/mining-history?days=${days}`),
+        };
+        this.territories = {
+            list: (token, params) => {
+                const p = params || {};
+                let qs = `?page=${p.page || 1}&page_size=${p.page_size || 20}`;
+                if (p.unit_type)
+                    qs += `&unit_type=${p.unit_type}`;
+                if (p.parent_id)
+                    qs += `&parent_id=${p.parent_id}`;
+                return request(this.base, `/territories${qs}`, token);
+            },
+            getSummary: (token) => request(this.base, '/territories/summary', token),
+            getDetail: (token, id) => request(this.base, `/territories/${id}`, token),
+            getStats: (token, id) => request(this.base, `/territories/${id}/stats`, token),
+            getMembers: (token, id, params) => {
+                const p = params || {};
+                return request(this.base, `/territories/${id}/members?page=${p.page || 1}&page_size=${p.page_size || 20}`, token);
+            },
+            getIncomeChart: (token, id, period = '30d') => request(this.base, `/territories/${id}/income-chart?period=${period}`, token),
+            getKpiHistory: (token, id) => request(this.base, `/territories/${id}/kpi-history`, token),
+            getMemberRanking: (token, id, params) => {
+                const p = params || {};
+                return request(this.base, `/territories/${id}/member-ranking?page=${p.page || 1}&page_size=${p.page_size || 20}`, token);
+            },
+            update: (token, id, data) => putRequest(this.base, `/territories/${id}`, data, token),
+            updateName: (token, id, name, force = false) => putRequest(this.base, `/territories/${id}/name${force ? '?force=true' : ''}`, { name }, token),
         };
         this.territory = {
             getCollection: () => request(this.base, '/territory/collection'),
             getNft: (mint) => request(this.base, `/territory/nft/${mint}`),
             getUserNfts: (wallet) => request(this.base, `/territory/nfts/${wallet}`),
         };
+        this.voting = {
+            getProposals: (token, params) => {
+                const p = params || {};
+                let qs = `?page=${p.page || 1}&page_size=${p.page_size || 20}`;
+                if (p.status)
+                    qs += `&status=${p.status}`;
+                return request(this.base, `/voting/proposals${qs}`, token);
+            },
+            getDetail: (token, id) => request(this.base, `/voting/proposals/${id}`, token),
+            getPower: (token) => request(this.base, '/voting/power', token),
+            createProposal: (token, data) => postRequest(this.base, '/voting/proposals', data, token),
+            castVote: (token, proposalId, data) => postRequest(this.base, `/voting/proposals/${proposalId}/vote`, data, token),
+        };
         this.auctions = {
             getConfig: () => request(this.base, '/auction-solana/config'),
             getActive: () => request(this.base, '/auction-solana/active'),
             getDetails: (id) => request(this.base, `/auction-solana/auction/${id}`),
             getBids: (id) => request(this.base, `/auction-solana/auction/${id}/bids`),
+            getUserBids: (wallet) => request(this.base, `/auction-solana/bids/${wallet}`),
+            getUserAuctions: (wallet) => request(this.base, `/auction-solana/auctions/${wallet}`),
+            getMyBids: (token) => request(this.base, '/auction-solana/my-bids', token),
+            placeBid: (token, auctionId, bidAmount) => postRequest(this.base, `/auction-solana/auction/${auctionId}/bid`, { bid_amount: bidAmount }, token),
+            prepareCancelBid: (token, auctionId) => postRequest(this.base, '/auction-solana/bid/cancel/prepare', { auction_id: auctionId }, token),
+            getHistory: (params) => {
+                const p = params || {};
+                return request(this.base, `/auction-solana/history?page=${p.page || 1}&page_size=${p.page_size || 20}`);
+            },
         };
         this.techTree = {
             getConfig: () => request(this.base, '/tech-tree/config'),

package/dist/types.d.ts

@@ -80,3 +80,213 @@ export interface MCCPrice {
     source: string;
     updated_at: string;
 }
+export interface Wallet {
+    wallet_address: string;
+    wallet_type: string;
+    is_primary: boolean;
+    created_at: string;
+}
+export interface TokenPortfolio {
+    sol_balance?: number;
+    mcc_balance?: number;
+    usdt_balance?: number;
+    usdc_balance?: number;
+    [key: string]: number | undefined;
+}
+export interface MCCLock {
+    lock_id: string;
+    amount: number;
+    reason: string;
+    lock_start: string;
+    lock_end: string;
+    status: string;
+}
+export interface MiningRatio {
+    current_stage?: number;
+    total_minted?: number;
+    ratio?: number;
+    usdc_per_mcc?: number;
+    current_rate?: number;
+}
+export interface MiningDistribution {
+    user_mcc: number;
+    team_mcc: number;
+    magistrate_mcc: number;
+    vault_mcd: number;
+    source: string;
+    territory_id?: string;
+    tx_signature?: string;
+    created_at: string;
+}
+export interface BuybackQuote {
+    mcc_amount: number;
+    market_price: number;
+    buyback_price: number;
+    usdc_amount: number;
+    premium_amount: number;
+}
+export interface BuybackRecord {
+    mcc_amount: number;
+    usdc_amount: number;
+    stablecoin: string;
+    tx_signature?: string;
+    buyback_price?: number;
+    created_at: string;
+}
+export interface Territory {
+    unit_id: string;
+    unit_name: string;
+    short_id?: string;
+    unit_type: string;
+    description?: string;
+    location?: string;
+    image_url?: string;
+    parent_id?: string;
+    member_count?: number;
+    max_capacity?: number;
+    vault_balance?: number;
+    manager_uid?: string;
+}
+export interface TerritorySummary {
+    total_stations: number;
+    total_members: number;
+    total_vault_mcd: number;
+    avg_kpi_score?: number;
+}
+export interface TerritoryStats {
+    member_count: number;
+    max_capacity: number;
+    vault_mcd: number;
+    occupancy_rate: number;
+}
+export interface TerritoryMember {
+    uid: string;
+    display_name?: string;
+    level?: string;
+    mcd_received?: number;
+    joined_at?: string;
+}
+export interface Proposal {
+    id: string;
+    title: string;
+    description: string;
+    proposal_type: string;
+    status: string;
+    options: string[];
+    min_votes?: number;
+    ends_at: string;
+    created_at: string;
+}
+export interface ProposalDetail extends Proposal {
+    vote_results: VoteResult[];
+}
+export interface VoteResult {
+    option: string;
+    votes: number;
+    mcc_total: number;
+    voter_count: number;
+}
+export interface VotePower {
+    vote_power: number;
+    user_rank?: string;
+    cost_per_vote_mcc?: number;
+    mcc_balance?: number;
+    max_votes?: number;
+    can_vote: boolean;
+}
+export interface AuctionBid {
+    bid_id?: string;
+    auction_id: number;
+    unit_name?: string;
+    bid_amount: number;
+    deposit_amount?: number;
+    status: string;
+    created_at: string;
+}
+export interface MCDTransaction {
+    id: string;
+    tx_type: string;
+    amount: number;
+    from_account_type?: string;
+    to_account_type?: string;
+    created_at: string;
+}
+export interface MCDReward {
+    id: string;
+    reward_date: string;
+    territory_id?: string;
+    mcd_received: number;
+    created_at: string;
+}
+export interface MiningRequest {
+    mcc_amount: number;
+    stablecoin?: string;
+    wallet_address: string;
+}
+export interface MiningConfirmData {
+    request_id: string;
+    tx_signature: string;
+    mcc_amount: number;
+    usdc_amount: number;
+    stablecoin_type?: string;
+}
+export interface MiningRequestResult {
+    request_id: string;
+    mcc_amount: number;
+    usdc_amount: number;
+    mining_price: number;
+    stablecoin: string;
+    payment_address: string;
+    expires_at: string;
+}
+export interface MiningConfig {
+    program_id: string;
+    pool_address: string;
+    mcc_mint: string;
+    usdt_mint: string;
+    usdc_mint: string;
+    distribution_ratios: Record<string, number>;
+    min_amount: number;
+    max_amount: number;
+}
+export interface BuybackRecordInput {
+    tx_signature: string;
+    wallet_address: string;
+    mcc_amount: number;
+    usdc_amount: number;
+    stablecoin?: string;
+}
+export interface ReincarnationConfig {
+    program_id: string;
+    pool_address: string;
+    mcc_vault: string;
+    usdc_vault: string;
+    usdt_vault: string;
+    min_buyback: number;
+    max_buyback: number;
+    premium_rate: number;
+}
+export interface MCCHistoryRecord {
+    mcc_amount: number;
+    stablecoin_amount: number;
+    stablecoin: string;
+    tx_signature: string;
+    type: string;
+    wallet_address?: string;
+    created_at: string;
+}
+export interface CycleHistory {
+    cycle_id: number;
+    executed_at: string;
+    mcc_returned: number;
+    mcd_returned: number;
+    status: string;
+}
+export interface AuctionHistory {
+    auction_id: number;
+    unit_name: string;
+    winner_wallet?: string;
+    winning_bid?: number;
+    status: string;
+    ended_at: string;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@microcosmmoney/auth-core",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "description": "Microcosm OAuth 2.0 authentication core library",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",