@arken/seer-protocol 0.1.0

package/src/modules/isles/isles.schema.ts

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

package/src/modules/isles/isles.service.ts

@@ -0,0 +1,40 @@
+import type { RouterContext, RouterInput, RouterOutput } from './isles.types';
+import { getFilter } from '@arken/node/util/api';
+import { ARXError } from '@arken/node/util/rpc';
+import * as Arken from '@arken/node';
+
+export class Service {
+  async saveRound(input: RouterInput['saveRound'], ctx: RouterContext): Promise<RouterOutput['saveRound']> {
+    console.log('Evolution.Service.saveRound', input);
+  }
+
+  async interact(input: RouterInput['interact'], ctx: RouterContext): Promise<RouterOutput['interact']> {
+    console.log('Evolution.Service.interact', input);
+  }
+
+  async getScene(input: RouterInput['getScene'], ctx: RouterContext): Promise<RouterOutput['getScene']> {
+    if (!input) throw new Error('Input should not be void');
+    console.log('Evolution.Service.getScene', input);
+
+    let data = {};
+
+    if (input.data.applicationId === '668e4e805f9a03927caf883b') {
+      data = {
+        ...data,
+        objects: [
+          {
+            id: 'adsad',
+            file: 'asdasdas.fbx',
+            position: {
+              x: 1000,
+              y: 1000,
+              z: 1000,
+            },
+          },
+        ] as Arken.Core.Types.Object,
+      };
+    }
+
+    return data;
+  }
+}

package/src/modules/isles/isles.types.ts

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+import { Model, Document } from '@arken/node/util/mongo';
+import * as schema from './isles.schema';
+
+export type * from './isles.router';
+export type * from './isles.service';
+export type { RouterContext } from '../../types';
+
+// // Define types based on the schema
+// export type Game = z.infer<typeof schema.Game>;
+// export type GameDocument = Game & Document;
+
+// export type GameStat = z.infer<typeof schema.GameStat>;
+// export type GameStatDocument = GameStat & Document;
+
+// export type Era = z.infer<typeof schema.Era>;
+// export type EraDocument = Era & Document;
+
+// Mappings for MongoDB models
+export type Mappings = {};

package/src/modules/oasis/index.ts

@@ -0,0 +1,5 @@
+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/src/modules/oasis/oasis.models.ts

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

package/src/modules/oasis/oasis.router.ts

@@ -0,0 +1,68 @@
+import { z as zod } from 'zod';
+import { initTRPC } from '@trpc/server';
+import { customErrorFormatter, hasRole } from '@arken/node/util/rpc';
+import * as Arken from '@arken/node';
+import { Query, getQueryInput, inferRouterOutputs, inferRouterInputs } from '@arken/node/schema';
+import { RouterContext } from '../../types';
+
+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({
+    getPatrons: procedure
+      .use(hasRole('guest', t))
+      .use(customErrorFormatter(t))
+      .output(z.array(Arken.Profile.Schemas.Profile))
+      .query(({ input, ctx }) => (ctx.app.service.Oasis.getPatrons as any)(input, ctx)),
+
+    interact: t.procedure
+      .input(
+        z.object({
+          shardId: z.string(),
+          roundId: z.number(),
+          round: z.any(),
+          rewardWinnerAmount: z.number(),
+          lastClients: z.any(),
+        })
+      )
+      .mutation(({ input, ctx }) => {
+        return { status: 1 };
+      }),
+
+    getScene: t.procedure
+      .input(
+        z.object({
+          data: z.any(),
+          signature: z.object({ hash: z.string(), address: z.string() }),
+        })
+      )
+      .query(({ input, ctx }) => {
+        let data = {};
+
+        if (input.data.applicationId === '668e4e805f9a03927caf883b') {
+          data = {
+            ...data,
+            objects: [
+              {
+                id: 'adsad',
+                file: 'asdasdas.fbx',
+                position: {
+                  x: 1000,
+                  y: 1000,
+                  z: 1000,
+                },
+              },
+            ] as Arken.Core.Types.Object,
+          };
+        }
+
+        return data;
+      }),
+  });
+
+export type Router = ReturnType<typeof createRouter>;
+export type RouterInput = inferRouterInputs<Router>;
+export type RouterOutput = inferRouterOutputs<Router>;

package/src/modules/oasis/oasis.schema.ts

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

package/src/modules/oasis/oasis.service.ts

@@ -0,0 +1,38 @@
+import type { RouterContext, RouterInput, RouterOutput } from './oasis.types';
+import { getFilter } from '@arken/node/util/api';
+import { ARXError } from '@arken/node/util/rpc';
+import * as Arken from '@arken/node';
+
+export class Service {
+  async getPatrons(input: RouterInput['getPatrons'], ctx: RouterContext): Promise<RouterOutput['getPatrons']> {
+    console.log('Oasis.Service.getPatrons', input);
+
+    const cubes = await ctx.app.model.Item.aggregate([
+      { $match: { name: "Founder's Cube" } },
+      { $sort: { quantity: -1 } },
+      { $limit: 15 },
+      {
+        $lookup: {
+          from: 'Character',
+          localField: 'characterId',
+          foreignField: '_id',
+          as: 'character',
+        },
+      },
+      { $unwind: '$character' },
+      {
+        $lookup: {
+          from: 'Profile',
+          localField: 'character.profileId',
+          foreignField: '_id',
+          as: 'character.profile',
+        },
+      },
+      { $unwind: '$character.profile' },
+    ]);
+    console.log(cubes);
+    const profiles = cubes.map((ticket: any) => ticket.character?.profile);
+
+    return profiles as Arken.Profile.Types.Profile[];
+  }
+}

package/src/modules/oasis/oasis.types.ts

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+import { Model, Document } from '@arken/node/util/mongo';
+import * as schema from './oasis.schema';
+
+export type * from './oasis.router';
+export type * from './oasis.service';
+export type { RouterContext } from '../../types';
+
+// // Define types based on the schema
+// export type Game = z.infer<typeof schema.Game>;
+// export type GameDocument = Game & Document;
+
+// export type GameStat = z.infer<typeof schema.GameStat>;
+// export type GameStatDocument = GameStat & Document;
+
+// export type Era = z.infer<typeof schema.Era>;
+// export type EraDocument = Era & Document;
+
+// Mappings for MongoDB models
+export type Mappings = {};

package/src/modules/trek/index.ts

@@ -0,0 +1,5 @@
+export type * as Types from './trek.types';
+export * as Models from './trek.models';
+export * as Schemas from './trek.schema';
+export * from './trek.router';
+export * from './trek.service';

package/src/modules/trek/trek.models.ts

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

package/src/modules/trek/trek.router.ts

@@ -0,0 +1,78 @@
+// arken/packages/seer/packages/protocol/src/modules/trek/trek.router.ts
+
+import { z as zod } from 'zod';
+import { initTRPC } from '@trpc/server';
+import { customErrorFormatter, hasRole } from '@arken/node/util/rpc';
+import type { inferRouterOutputs, inferRouterInputs } from '@trpc/server';
+import type { RouterContext } from '../../types';
+
+export const z = zod;
+export const t = initTRPC.context<RouterContext>().create();
+export const router = t.router;
+export const procedure = t.procedure;
+
+// If you want stricter outputs later you can add .output() schemas.
+// For now we keep it flexible while wiring up the service.
+
+export const createRouter = () =>
+  router({
+    /**
+     * Read current trek state for the active character.
+     * UI calls this as: trpc.trek.getState.useQuery({ metaverseId, trekId })
+     */
+    getState: procedure
+      .use(hasRole('guest', t))
+      .use(customErrorFormatter(t))
+      .input(
+        z.object({
+          metaverseId: z.string().optional(),
+          trekId: z.string().optional(), // aka defKey
+        })
+      )
+      .query(({ input, ctx }) => {
+        return (ctx.app.service.Trek as any).getState(
+          {
+            defKey: input?.trekId || 'trek.default',
+            metaverseId: input?.metaverseId,
+          },
+          ctx
+        );
+      }),
+
+    /**
+     * Generate the next open node IF no open node exists.
+     * Equivalent to "Next Stop" in UI.
+     */
+    nextStop: procedure
+      .use(hasRole('user', t))
+      .use(customErrorFormatter(t))
+      .input(
+        z.object({
+          trekId: z.string().optional(), // aka defKey
+        })
+      )
+      .mutation(({ input, ctx }) => {
+        return (ctx.app.service.Trek as any).nextStop({ defKey: input?.trekId || 'trek.default' }, ctx);
+      }),
+
+    /**
+     * Choose a choice on the open node.
+     */
+    choose: procedure
+      .use(hasRole('user', t))
+      .use(customErrorFormatter(t))
+      .input(
+        z.object({
+          runId: z.string(),
+          nodeId: z.string(),
+          choiceId: z.string(),
+        })
+      )
+      .mutation(({ input, ctx }) => {
+        return (ctx.app.service.Trek as any).choose(input, ctx);
+      }),
+  });
+
+export type Router = ReturnType<typeof createRouter>;
+export type RouterInput = inferRouterInputs<Router>;
+export type RouterOutput = inferRouterOutputs<Router>;

package/src/modules/trek/trek.schema.ts

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