@arken/seer-protocol 0.1.1 → 0.1.3

package/job/job.schema.ts

@@ -0,0 +1,9 @@
+import { z, ObjectId, Entity } from '../schema';
+
+export const Job = Entity.merge(
+  z.object({
+    mod: z.string(),
+    startDate: z.date().optional(),
+    expireDate: z.date().optional(),
+  })
+);

package/job/job.types.ts

@@ -0,0 +1,22 @@
+// module/job.types.ts
+
+import { z } from 'zod';
+import * as schema from './job.schema';
+import { Document, Model } from '@arken/node/mongo';
+import type { RouterContext } from '../types';
+import type { inferRouterInputs, inferRouterOutputs } from '@trpc/server';
+import type { Router } from './job.router';
+
+export type * from './job.router';
+export type { RouterContext };
+
+export type Job = z.infer<typeof schema.Job>;
+
+export type JobDocument = Job & Document;
+
+export type Mappings = {
+  Job: Model<JobDocument>;
+};
+
+export type RouterInput = inferRouterInputs<Router>;
+export type RouterOutput = inferRouterOutputs<Router>;

package/market/index.ts

@@ -0,0 +1,4 @@
+export * as Types from './market.types';
+export * as Models from './market.models';
+export * as Schemas from './market.schema';
+export * from './market.router';

package/market/market.models.ts

@@ -0,0 +1,113 @@
+import * as mongo from '@arken/node/mongo';
+import type * as Types from './market.types';
+
+export const Market = mongo.createModel<Types.MarketDocument>('Market', {
+  value: { type: String, required: true },
+});
+
+export const MarketPair = mongo.createModel<Types.MarketPairDocument>('MarketPair', {
+  value: { type: String, required: true },
+});
+
+export const MarketExchange = mongo.createModel<Types.MarketExchangeDocument>('MarketExchange', {
+  value: { type: String },
+});
+
+export const MarketAnalysis = mongo.createModel<Types.MarketAnalysisDocument>('MarketAnalysis', {
+  action: { type: String, required: true },
+  asset: { type: String, required: true },
+  signalType: { type: String, required: true },
+  confidence: { type: Number, required: true },
+  riskLevel: { type: String, required: true },
+  timeFrame: { type: String, required: true },
+  source: { type: String, required: true },
+  summary: { type: String, required: true },
+  labels: {
+    sector: { type: String },
+    topic: { type: String },
+    sentiment: { type: String },
+  },
+});
+
+export const MarketInvestor = mongo.createModel<Types.MarketInvestorDocument>('MarketInvestor', {
+  portfolioIds: [{ type: mongo.Schema.Types.ObjectId, required: true }],
+  totalPnl: { type: Number },
+});
+
+export const MarketInvestmentPortfolio = mongo.createModel<Types.MarketInvestmentPortfolioDocument>(
+  'MarketInvestmentPortfolio',
+  {
+    categoryGoals: [
+      {
+        category: { type: String, required: true },
+        goalPercentage: { type: Number, required: true },
+        currentPnL: { type: Number },
+        historicalPnL: { type: Number },
+      },
+    ],
+    investmentIds: [{ type: mongo.Schema.Types.ObjectId, required: true }],
+    totalPnl: { type: Number },
+  }
+);
+
+export const MarketInvestment = mongo.createModel<Types.MarketInvestmentDocument>('MarketInvestment', {
+  type: { type: String, required: true },
+  amount: { type: Number, required: true },
+  category: { type: String, required: true },
+  purchasePrice: { type: Number, required: true },
+  currentValue: { type: Number, required: true },
+  pnl: { type: Number, required: true },
+  transactions: [
+    {
+      date: { type: Date, required: true },
+      type: { type: String, required: true },
+      price: { type: Number, required: true },
+      quantity: { type: Number, required: true },
+    },
+  ],
+  stockId: { type: mongo.Schema.Types.ObjectId },
+  chainTokenId: { type: mongo.Schema.Types.ObjectId },
+});
+
+export const MarketStock = mongo.createModel<Types.MarketStockDocument>('MarketStock', {
+  ticker: { type: String, required: true },
+  companyId: { type: mongo.Schema.Types.ObjectId, required: true, ref: 'StockCompany' },
+  currentPrice: { type: Number, required: true },
+  marketCap: { type: Number },
+  volume: { type: Number },
+  currency: { type: String, required: true },
+  aum: { type: Number },
+  quoteType: { type: String },
+  dailyChange: { type: Number },
+  dailyChangePercent: { type: Number },
+});
+
+export const MarketToken = mongo.createModel<Types.MarketTokenDocument>('MarketToken', {
+  symbol: { type: String, required: true },
+  currentPrice: { type: Number, required: true },
+});
+
+export const MarketCompany = mongo.createModel<Types.MarketCompanyDocument>('MarketCompany', {
+  ticker: { type: String, required: true },
+  country: { type: String, required: true },
+  industry: { type: String, required: true },
+  sector: { type: String, required: true },
+  type: { type: String, required: true },
+  issuedETFs: [{ type: mongo.Schema.Types.ObjectId, ref: 'MarketETF' }],
+});
+
+export const MarketETF = mongo.createModel<Types.MarketETFDocument>('ETF', {
+  ticker: { type: String, required: true },
+  issuerId: { type: mongo.Schema.Types.ObjectId, required: true },
+  leverage: { type: Number, required: false },
+});
+
+export const MarketStockSentiment = mongo.createModel<Types.MarketStockSentimentDocument>('MarketStockSentiment', {
+  ticker: { type: String, required: true },
+  companyId: { type: mongo.Schema.Types.ObjectId, required: true, ref: 'StockCompany' },
+  sentiment: {
+    label: { type: String, required: true },
+    score: { type: Number, required: true },
+  },
+  confidence: { type: Number, required: true },
+});

package/market/market.router.ts

@@ -0,0 +1,73 @@
+// module/market.router.ts
+
+import { z as zod } from 'zod';
+import { initTRPC, inferRouterInputs, inferRouterOutputs } from '@trpc/server';
+import { customErrorFormatter, hasRole } from '@arken/node/rpc';
+import type { RouterContext } from '../types';
+import { Market, MarketPair, MarketExchange } from './market.schema';
+
+export const z = zod;
+export const t = initTRPC.context<RouterContext>().create();
+export const router = t.router;
+export const procedure = t.procedure;
+
+export const createRouter = () =>
+  router({
+    getMarket: procedure
+      .use(hasRole('guest', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ marketId: z.string() }))
+      .query(({ input, ctx }) => (ctx.app.service.Market.getMarket as any)(input, ctx)),
+
+    createMarket: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(Market)
+      .mutation(({ input, ctx }) => (ctx.app.service.Market.createMarket as any)(input, ctx)),
+
+    updateMarket: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ marketId: z.string(), data: Market.partial() }))
+      .mutation(({ input, ctx }) => (ctx.app.service.Market.updateMarket as any)(input, ctx)),
+
+    getMarketPair: procedure
+      .use(hasRole('guest', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ marketPairId: z.string() }))
+      .query(({ input, ctx }) => (ctx.app.service.Market.getMarketPair as any)(input, ctx)),
+
+    createMarketPair: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(MarketPair)
+      .mutation(({ input, ctx }) => (ctx.app.service.Market.createMarketPair as any)(input, ctx)),
+
+    updateMarketPair: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ marketPairId: z.string(), data: MarketPair.partial() }))
+      .mutation(({ input, ctx }) => (ctx.app.service.Market.updateMarketPair as any)(input, ctx)),
+
+    getMarketExchange: procedure
+      .use(hasRole('guest', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ exchangeId: z.string() }))
+      .query(({ input, ctx }) => (ctx.app.service.Market.getMarketExchange as any)(input, ctx)),
+
+    createMarketExchange: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(MarketExchange)
+      .mutation(({ input, ctx }) => (ctx.app.service.Market.createMarketExchange as any)(input, ctx)),
+
+    updateMarketExchange: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ exchangeId: z.string(), data: MarketExchange.partial() }))
+      .mutation(({ input, ctx }) => (ctx.app.service.Market.updateMarketExchange as any)(input, ctx)),
+  });
+
+export type Router = ReturnType<typeof createRouter>;
+export type RouterInput = inferRouterInputs<Router>;
+export type RouterOutput = inferRouterOutputs<Router>;

package/market/market.schema.ts

@@ -0,0 +1,149 @@
+import { z, Entity, ObjectId } from '../schema';
+
+export const Market = Entity.merge(
+  z.object({
+    value: z.string(),
+  })
+);
+
+export const MarketPair = Entity.merge(
+  z.object({
+    value: z.string(),
+  })
+);
+
+export const MarketExchange = Entity.merge(
+  z.object({
+    value: z.string(),
+  })
+);
+
+export const MarketAnalysis = Entity.merge(
+  z.object({
+    action: z.enum(['Buy', 'Sell']), // buy or sell action
+    asset: z.string().min(1), // the asset being traded (e.g., oil, Bitcoin)
+    signalType: z.string().min(1), // type of signal (e.g., news)
+    confidence: z
+      .number()
+      .min(0)
+      .max(100), // confidence level from 0 to 100
+    riskLevel: z.enum(['Low', 'Medium', 'High']), // risk level
+    timeFrame: z.enum(['Short-Term', 'Long-Term']), // investment time frame
+    source: z.string().min(1), // source of information (e.g., FinancialJuice, Ground News)
+    summary: z.string().min(1), // summary of the analysis
+    labels: z.object({
+      sector: z.string().optional(), // sector related to the asset (e.g., energy, aviation)
+      topic: z.string().optional(), // topic of the news (e.g., oil demand, job cuts)
+      sentiment: z.enum(['Positive', 'Neutral', 'Negative']).optional(), // sentiment of the news
+    }),
+  })
+);
+
+export const MarketInvestor = Entity.merge(
+  z.object({
+    portfolioIds: z.array(ObjectId), // Array of ObjectId references to InvestmentPortfolio
+    totalPnl: z.number().optional(), // Total profit and loss
+  })
+);
+
+export const MarketInvestmentPortfolio = Entity.merge(
+  z.object({
+    categoryGoals: z.array(
+      z.object({
+        category: z.string(), // Category name
+        goalPercentage: z.number(), // Goal percentage for this category
+        currentPnl: z.number().optional(), // Current P&L for this category
+        historicalPnL: z.number().optional(), // Historical P&L for this category
+      })
+    ), // Array of categories with goal percentages and P&L tracking
+    investmentIds: z.array(ObjectId), // Array of ObjectId references to Investment
+    totalPnl: z.number().optional(), // Total P&L for this portfolio
+  })
+);
+
+export const MarketInvestment = Entity.merge(
+  z.object({
+    type: z.enum(['Stock', 'ChainToken']),
+    category: z.enum(['Historically Safe', 'Economy Bull', 'Economy Bear', 'Custom']),
+    amount: z.number(), // Initial amount invested
+    purchasePrice: z.number(), // Price at which the investment was purchased
+    currentValue: z.number().optional(), // Current value of the investment
+    pnl: z.number().optional(), // Current P&L of the investment
+    transactions: z
+      .array(
+        z.object({
+          date: z.string(), // Date of transaction
+          type: z.enum(['Buy', 'Sell']),
+          price: z.number(), // Price at transaction
+          quantity: z.number(), // Quantity bought or sold
+        })
+      )
+      .optional(), // Optional array for detailed transaction history
+    stockId: ObjectId.optional(), // Reference to Stock if type is 'Stock'
+    chainTokenId: ObjectId.optional(), // Reference to ChainToken if type is 'ChainToken'
+  })
+);
+
+export const MarketStock = Entity.merge(
+  z.object({
+    ticker: z.string(),
+    companyId: ObjectId,
+    marketCap: z.number().optional(),
+    aum: z.number().optional(),
+    quoteType: z.string(),
+    currentPrice: z.number(),
+    dailyChange: z.number().optional(),
+    dailyChangePercent: z.number().optional(),
+    volume: z.number(),
+    currency: z.string(),
+  })
+);
+
+export const MarketToken = Entity.merge(
+  z.object({
+    symbol: z.string(),
+    currentPrice: z.number(),
+  })
+);
+
+export const MarketCompany = Entity.merge(
+  z.object({
+    ticker: z.string(), // Primary ticker, if applicable
+    type: z.enum(['Public Company', 'ETF Issuer', 'Both', 'Other']), // Categorize the company type
+    country: z.string().optional(), // Country where the company is based
+    industry: z.string().optional(), // Industry the company operates in
+    sector: z.string().optional(), // Sector the company belongs to
+    issuedETFs: z.array(ObjectId).optional(), // References to ETFs issued by this company
+  })
+);
+
+export const MarketETF = Entity.merge(
+  z.object({
+    ticker: z.string(),
+    issuerId: ObjectId, // Reference to the Company issuing the ETF
+    leverage: z.number().optional(), // Leverage factor if applicable (e.g., 3x)
+    country: z.string().optional(), // Country where the ETF is based
+    currency: z.string().optional(), // Currency the ETF is traded in
+    AUM: z.number().optional(), // Assets under management
+    industry: z.string().optional(), // Industry the ETF is focused on
+    sector: z.string().optional(), // Sector the ETF is focused on
+  })
+);
+
+export const MarketStockSentiment = Entity.merge(
+  z.object({
+    ticker: z.string(),
+    companyId: ObjectId,
+    sentiment: z.object({
+      label: z.enum(['Positive', 'Neutral', 'Negative']), // predefined sentiment labels
+      score: z
+        .number()
+        .min(0)
+        .max(1), // sentiment score as a confidence percentage
+    }),
+    confidence: z
+      .number()
+      .min(0)
+      .max(1), // overall confidence level for the analysis
+  })
+);

package/market/market.types.ts

@@ -0,0 +1,55 @@
+// module/market.types.ts
+
+import { z } from 'zod';
+import * as schema from './market.schema';
+import { Document, Model } from '@arken/node/mongo';
+import type { RouterContext } from '../types';
+import type { inferRouterInputs, inferRouterOutputs } from '@trpc/server';
+import type { Router } from './market.router';
+
+export type * from './market.router';
+export type { RouterContext };
+
+export type Market = z.infer<typeof schema.Market>;
+export type MarketPair = z.infer<typeof schema.MarketPair>;
+export type MarketExchange = z.infer<typeof schema.MarketExchange>;
+export type MarketAnalysis = z.infer<typeof schema.MarketAnalysis>;
+export type MarketInvestor = z.infer<typeof schema.MarketInvestor>;
+export type MarketInvestmentPortfolio = z.infer<typeof schema.MarketInvestmentPortfolio>;
+export type MarketInvestment = z.infer<typeof schema.MarketInvestment>;
+export type MarketStock = z.infer<typeof schema.MarketStock>;
+export type MarketToken = z.infer<typeof schema.MarketToken>;
+export type MarketCompany = z.infer<typeof schema.MarketCompany>;
+export type MarketETF = z.infer<typeof schema.MarketETF>;
+export type MarketStockSentiment = z.infer<typeof schema.MarketStockSentiment>;
+
+export type MarketDocument = Market & Document;
+export type MarketPairDocument = MarketPair & Document;
+export type MarketExchangeDocument = MarketExchange & Document;
+export type MarketAnalysisDocument = MarketAnalysis & Document;
+export type MarketInvestorDocument = MarketInvestor & Document;
+export type MarketInvestmentPortfolioDocument = MarketInvestmentPortfolio & Document;
+export type MarketInvestmentDocument = MarketInvestment & Document;
+export type MarketStockDocument = MarketStock & Document;
+export type MarketTokenDocument = MarketToken & Document;
+export type MarketCompanyDocument = MarketCompany & Document;
+export type MarketETFDocument = MarketETF & Document;
+export type MarketStockSentimentDocument = MarketStockSentiment & Document;
+
+export type Mappings = {
+  Market: Model<MarketDocument>;
+  MarketPair: Model<MarketPairDocument>;
+  MarketExchange: Model<MarketExchangeDocument>;
+  MarketAnalysis: Model<MarketAnalysisDocument>;
+  MarketInvestor: Model<MarketInvestorDocument>;
+  MarketInvestmentPortfolio: Model<MarketInvestmentPortfolioDocument>;
+  MarketInvestment: Model<MarketInvestmentDocument>;
+  MarketStock: Model<MarketStockDocument>;
+  MarketToken: Model<MarketTokenDocument>;
+  MarketCompany: Model<MarketCompanyDocument>;
+  MarketETF: Model<MarketETFDocument>;
+  MarketStockSentiment: Model<MarketStockSentimentDocument>;
+};
+
+export type RouterInput = inferRouterInputs<Router>;
+export type RouterOutput = inferRouterOutputs<Router>;

package/oasis/index.ts

@@ -2,4 +2,3 @@ export type * as Types from './oasis.types';
 export * as Models from './oasis.models';
 export * as Schemas from './oasis.schema';
 export * from './oasis.router';
-export * from './oasis.service';

package/oasis/oasis.models.ts

@@ -1,3 +1,3 @@
-import * as mongo from '@arken/mongo';
+import * as mongo from '@arken/node/mongo';
 
 const { addTagVirtuals, addApplicationVirtual } = mongo;

package/oasis/oasis.router.ts

@@ -1,9 +1,8 @@
 import { z as zod } from 'zod';
 import { initTRPC } from '@trpc/server';
-import { customErrorFormatter, hasRole } from '@arken/rpc';
-import * as Arken from '@arken/node';
-import { Query, getQueryInput, inferRouterOutputs, inferRouterInputs } from '@arken/schema';
-import { RouterContext } from '../../types';
+import { customErrorFormatter, hasRole } from '@arken/node/rpc';
+import { Query, getQueryInput, inferRouterOutputs, inferRouterInputs } from '@arken/node/schema';
+import { RouterContext, Core, Profile } from '../types';
 
 export const z = zod;
 export const t = initTRPC.context<RouterContext>().create();
@@ -15,7 +14,7 @@ export const createRouter = () =>
     getPatrons: procedure
       .use(hasRole('guest', t))
       .use(customErrorFormatter(t))
-      .output(z.array(Arken.Profile.Schemas.Profile))
+      .output(z.array(Profile.Schemas.Profile))
       .query(({ input, ctx }) => (ctx.app.service.Oasis.getPatrons as any)(input, ctx)),
 
     interact: t.procedure
@@ -55,7 +54,7 @@ export const createRouter = () =>
                   z: 1000,
                 },
               },
-            ] as Arken.Core.Types.Object,
+            ] as Core.Types.Object,
           };
         }
 

package/oasis/oasis.schema.ts

@@ -1 +1 @@
-import { z, ObjectId, Entity } from '@arken/schema';
+import { z, ObjectId, Entity } from '@arken/node/schema';

package/oasis/oasis.types.ts

@@ -1,10 +1,9 @@
 import { z } from 'zod';
-import { Model, Document } from '@arken/mongo';
+import { Model, Document } from '@arken/node/mongo';
 import * as schema from './oasis.schema';
 
 export type * from './oasis.router';
-export type * from './oasis.service';
-export type { RouterContext } from '../../types';
+export type { RouterContext } from '../types';
 
 // // Define types based on the schema
 // export type Game = z.infer<typeof schema.Game>;

package/package.json

@@ -1,16 +1,29 @@
 {
   "name": "@arken/seer-protocol",
-  "version": "0.1.1",
-  "main": "src/index.ts",
-  "scripts": {},
+  "version": "0.1.3",
+  "main": "index.ts",
+  "scripts": {
+    "build": "npm-run-all dist",
+    "clean": "del-cli ./build && make-dir ./build",
+    "dist": "npm-run-all clean tsc:*",
+    "publish": "npm publish --access=public",
+    "tsc:1": "rm -rf ./build && mkdir ./build && cp package.json ./build && NODE_ENV=production NODE_OPTIONS=--max-old-space-size=8192 tsc --listFiles"
+  },
   "dependencies": {
+    "@arken/node": "^1.5.3",
     "@arken/forge-protocol": "^0.1.1",
     "@trpc/client": "11.0.0-rc.660",
     "@trpc/server": "11.0.0-rc.660",
+    "make-dir-cli": "^3",
+    "jest": "^29",
+    "@types/jest": "^29",
+    "@types/node": "^20",
     "zod": "^3",
     "dotenv": "^16",
     "lodash": "^4",
     "dayjs": "^1"
   },
-  "devDependencies": {}
+  "devDependencies": {
+    "del-cli": "^5"
+  }
 }

package/product/index.ts

@@ -0,0 +1,4 @@
+export * as Types from './product.types';
+export * as Models from './product.models';
+export * as Schemas from './product.schema';
+export * from './product.router';