@arken/node 1.5.0 → 1.5.2

package/index.ts

@@ -1,18 +1,351 @@
-export * as util from './util';
-export * as Area from './modules/area';
-export * as Asset from './modules/asset';
-export * as Chain from './modules/chain';
-export * as Character from './modules/character';
-export * as Chat from './modules/chat';
-export * as Collection from './modules/collection';
-export * as Core from './modules/core';
-export * as Game from './modules/game';
-export * as Interface from './modules/interface';
-export * as Item from './modules/item';
-export * as Job from './modules/job';
-export * as Market from './modules/market';
-export * as Product from './modules/product';
-export * as Profile from './modules/profile';
-export * as Raffle from './modules/raffle';
-export * as Skill from './modules/skill';
-export * as Video from './modules/video';
+import crypto from 'crypto';
+import { exec } from 'child_process';
+// import jetpack from 'fs-jetpack';
+import * as ethers from 'ethers';
+import _ from 'lodash';
+import config from './config';
+import * as time from './time';
+import * as objects from './object';
+import * as db from './db';
+import * as api from './api';
+import * as guid from './guid';
+import * as number from './number';
+import * as string from './string';
+import * as process2 from './process';
+import * as web3 from './web3';
+import * as math from './math';
+import * as json from './json';
+import * as format from './format';
+import * as rpc from './rpc';
+// import * as browser from './browser';
+
+export * as decoder from './decoder';
+
+const path = require('path');
+const writeLogs = false;
+const logPrefix = process.env.LOG_PREFIX || '[APP]';
+
+export const isDebug =
+  process.env.HOME === '/Users/dev' ||
+  process.env.HOME === '/home/dev' ||
+  process.env.HOME === '/root' ||
+  process.env.LOG === '1';
+
+export function logError(...msgs) {
+  console.log(logPrefix, nowReadable(), ...msgs);
+
+  // const errorLog = jetpack.read(path.resolve('./public/data/errors.json'), 'json') || [];
+
+  // for (const msg of msgs) {
+  //   errorLog.push(JSON.stringify(msg));
+  // }
+
+  if (writeLogs) {
+    // jetpack.write(path.resolve('./public/data/errors.json'), JSON.stringify(errorLog, null, 2), { atomic: true });
+  }
+
+  // console.log(msgs);
+
+  // throw new Error(msgs.join('; '));
+}
+
+export function log(...msgs) {
+  if (isDebug) {
+    console.log(logPrefix, nowReadable(), ...msgs);
+  }
+
+  if (writeLogs) {
+    // const logData = jetpack.read(path.resolve('../public/data/log.json'), 'json') || [];
+    // for (const msg of msgs) {
+    //   logData.push(JSON.stringify(msg));
+    // }
+    // jetpack.write(path.resolve('./public/data/log.json'), JSON.stringify(logData, null, 2));
+  }
+}
+
+export function nowReadable() {
+  return new Date().toISOString().replace(/T/, ' ').replace(/\..+/, '');
+}
+
+export function wait(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+export function round(num, precision) {
+  const _precision = 10 ** precision;
+  return Math.ceil(num * _precision) / _precision;
+}
+
+export function pad(n, width, z = '0') {
+  const nn = n + '';
+  return nn.length >= width ? nn : new Array(width - nn.length + 1).join(z) + nn;
+}
+
+export function removeDupes(list) {
+  const seen = {};
+  return list.filter(function (item) {
+    const k1 = item.seller + item.tokenId + item.blockNumber;
+    const k2 = item.id;
+    const exists = seen.hasOwnProperty(k1) || seen.hasOwnProperty(k2);
+
+    if (!exists) {
+      seen[k1] = true;
+      seen[k2] = true;
+    }
+
+    return !exists;
+  });
+}
+
+export const toLong = (x, decimals = 16) =>
+  decimals === 16 ? ethers.utils.parseEther(x + '') : ethers.utils.parseUnits(x + '', decimals);
+export const toShort = (x) => round(parseFloat(ethers.utils.formatEther(x)), 4);
+
+let updatingGit = false;
+
+export async function updateGit() {
+  if (updatingGit) return;
+
+  updatingGit = true;
+  try {
+    const execPromise = require('util').promisify(exec);
+
+    try {
+      await execPromise('rm ./db/.git/index.lock');
+    } catch (e2) {}
+
+    const { stdout, stderr } = await execPromise(
+      'cd db && git add -A && git commit -m "build: Binzy doz it" && git push --set-upstream origin master'
+    );
+
+    console.log(stderr, stdout);
+
+    await wait(100);
+  } catch (e) {
+    console.log(e);
+  }
+
+  updatingGit = false;
+}
+
+export function groupBySub(xs, key, subkey) {
+  return (
+    xs.reduce(function (rv, x) {
+      if (!x[key][subkey]) return rv;
+      (rv[x[key][subkey]] = rv[x[key][subkey]] || []).push(x);
+      return rv;
+    }, {}) || null
+  );
+}
+
+export function groupBy(xs, key) {
+  return (
+    xs.reduce(function (rv, x) {
+      if (!x[key]) return rv;
+      (rv[x[key]] = rv[x[key]] || []).push(x);
+      return rv;
+    }, {}) || null
+  );
+}
+
+export function getHighestId(arr) {
+  let highest = 0;
+
+  for (const item of arr) {
+    if (item.id > highest) {
+      highest = item.id;
+    }
+  }
+
+  return highest;
+}
+
+export function average(arr) {
+  return arr.reduce((p, c) => p + c, 0) / arr.length;
+}
+
+export function ordinalise(n) {
+  return (
+    n +
+    (n % 10 == 1 && n % 100 != 11
+      ? 'st'
+      : n % 10 == 2 && n % 100 != 12
+      ? 'nd'
+      : n % 10 == 3 && n % 100 != 13
+      ? 'rd'
+      : 'th')
+  );
+}
+export function commarise(n) {
+  return n.toString().replace(/\B(?=(\d{3})+(?!\d))/g, ',');
+}
+
+export function getTime() {
+  return new Date().getTime();
+}
+
+export const capitalizeFirstLetters = (text?: string) => text != null && _.startCase(text?.toLowerCase());
+
+export function convertToDecimal(byte) {
+  let result = 0;
+
+  byte = byte.split('');
+
+  byte.reverse();
+
+  for (let a = 0; a < byte.length; a++) {
+    if (byte[a] === '1') {
+      result += 2 ** a;
+    }
+  }
+
+  return result;
+}
+
+export const phoneMask = (phone: string) => {
+  //This regular expression provides the pattern for a phone number in format 000-000-0000
+  const x = phone.replace(/\D/g, '').match(/(\d{0,3})(\d{0,3})(\d{0,4})/);
+  return !x[2] ? x[1] : x[1] + '-' + x[2] + (x[3] ? '-' + x[3] : '');
+};
+
+export function binaryAgent(str) {
+  let bytes = str.split(' ');
+  let output = '';
+
+  for (let k = 0; k < bytes.length; k++) {
+    if (bytes[k]) output += String.fromCharCode(convertToDecimal(bytes[k]));
+  }
+
+  return output;
+}
+
+export function decodePayload(msg) {
+  try {
+    if (typeof msg === 'object') return msg;
+
+    // @ts-ignore
+    let json = binaryAgent(msg); //String.fromCharCode.apply(null, new Uint8Array(msg));
+    // else if (Buffer.isBuffer(msg)) json = msg.toString();
+
+    // explicitly decode the String as UTF-8 for Unicode
+    //   https://github.com/mathiasbynens/utf8.js
+    // json = utf8.decode(json)
+    // const buffer = Buffer.from(json, "binary");
+    if (typeof json === 'string') return JSON.parse(json);
+
+    return json;
+  } catch (err) {
+    // ...
+    console.log(err, msg);
+  }
+}
+
+export function isNumeric(str) {
+  if (typeof str != 'string') return false; // we only process strings!
+  return (
+    // @ts-ignore
+    !isNaN(str) && // use type coercion to parse the _entirety_ of the string (`parseFloat` alone does not do this)...
+    !isNaN(parseFloat(str))
+  ); // ...and ensure strings of whitespace fail
+}
+
+/**
+ * Wrapper around fetch with an optional timeout
+ * @param {Url} url
+ * @param {Request} request
+ * @param {number} timeout
+ */
+async function fetchWithTimeout(url, request, timeout) {
+  return Promise.race([
+    fetch(url, request),
+    new Promise((_, reject) => setTimeout(() => reject(new Error('Timeout')), timeout)),
+  ]);
+}
+
+export function sha256(str) {
+  return crypto.createHash('sha256').update(str, 'utf8').digest('base64');
+}
+
+// /**
+//  * sha256 encodes a given string message
+//  * @param {string} message
+//  * Borrowed from
+//  * https://developers.cloudflare.com/workers/examples/cache-api
+//  */
+// async function sha256(message) {
+//   // encode as UTF-8
+//   const msgBuffer = new TextEncoder().encode(message)
+//   // hash the message
+//   const hashBuffer = await crypto.subtle.digest("SHA-256", msgBuffer)
+//   // convert ArrayBuffer to Array
+//   const hashArray = Array.from(new Uint8Array(hashBuffer))
+//   // convert bytes to hex string
+//   const hashHex = hashArray.map(b => ("00" + b.toString(16)).slice(-2)).join("")
+//   return hashHex
+// }
+
+export function randomPosition(min, max) {
+  return Math.random() * (max - min) + min;
+}
+
+export function shuffleArray(array) {
+  for (let i = array.length - 1; i > 0; i--) {
+    const j = Math.floor(Math.random() * (i + 1));
+    [array[i], array[j]] = [array[j], array[i]];
+  }
+
+  return array;
+}
+
+export const getAddress = (address) => {
+  const mainNetChainId = 56;
+  const chainId = window?.location?.hostname === 'testnet.arken.gg' ? 97 : process.env.REACT_APP_CHAIN_ID;
+  return address[chainId] ? address[chainId] : address[mainNetChainId];
+};
+
+export function random(min, max) {
+  return Math.floor(Math.random() * (max - min + 1)) + min;
+}
+
+export const isEthereumAddress = (address: string) => {
+  // Regular expression to check if the string is a valid Ethereum address
+  return /^0x[a-fA-F0-9]{40}$/.test(address);
+};
+
+export const ipHashFromSocket = (socket) => {
+  const ip = socket.handshake.headers['x-forwarded-for']?.split(',')[0] || socket.conn.remoteAddress?.split(':')[3];
+  let hash = ip ? sha256(ip.slice(ip.length / 2)) : '';
+  hash = ip ? hash.slice(hash.length - 10, hash.length - 1) : '';
+
+  return hash;
+};
+
+export * as physics from './physics';
+export * as number from './number';
+export * as object from './object';
+export * as api from './api';
+export * as string from './string';
+export * as web3 from './web3';
+export * as math from './math';
+export * as db from './db';
+export * as time from './time';
+export * as config from './config';
+export * as rpc from './rpc';
+
+export default {
+  objects,
+  api,
+  guid,
+  number,
+  string,
+  process: process2,
+  web3,
+  math,
+  json,
+  db,
+  format,
+  rpc,
+  // browser,
+  config,
+  time,
+};

package/{util/mongo.ts → mongo.ts}

@@ -711,6 +711,7 @@ export function createSchema<T>(
     virtuals: true, // Include virtual fields
     versionKey: false, // Remove the __v version field
     transform: (doc, ret) => {
+      // @ts-ignore
       ret.id = ret._id.toString(); // Assign _id to id
       delete ret._id; // Remove _id from the output
       return ret;
@@ -721,6 +722,7 @@ export function createSchema<T>(
     virtuals: true, // Include virtual fields
     versionKey: false, // Remove the __v version field
     transform: (doc, ret) => {
+      // @ts-ignore
       ret.id = ret._id.toString(); // Assign _id to id
       delete ret._id; // Remove _id from the output
       return ret;

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@arken/node",
-  "version": "1.5.0",
+  "version": "1.5.2",
   "description": "",
-  "main": "index.ts",
-  "types": "types.ts",
+  "main": "build/index.js",
+  "types": "build/types.d.ts",
   "scripts": {
     "build": "npm-run-all dist",
     "clean": "del-cli ./build && make-dir ./build",

package/tsconfig.json

@@ -44,8 +44,39 @@
     "components/**/*",
     "hooks/**/*",
     "generated/**/*",
-    "util/**/*",
-    "util/types/mongo.d.ts",
+    "trpc/**/*",
+    "types/**/*",
+    "web3/**/*",
+    "./api.ts",
+    "./array.ts",
+    "./browser.ts",
+    "./codebase.ts",
+    "./db.ts",
+    "./decoder.ts",
+    "./format.ts",
+    "./guid.ts",
+    "./json.ts",
+    "./log.ts",
+    "./math.ts",
+    "./merkle.ts",
+    "./mongo.ts",
+    "./number.ts",
+    "./object.ts",
+    "./otp.ts",
+    "./physics.ts",
+    "./process.ts",
+    "./router.ts",
+    "./rpc.ts",
+    "./schema.ts",
+    "./seer.ts",
+    "./string.ts",
+    "./text.ts",
+    "./types.ts",
+    "./util.ts",
+    "./web3.ts",
+    "./websocket.ts",
+    "./zk.ts",
+    "./zod.ts",
     "legacy/**/*.json",
     "contracts/**/*.json",
     "generated/**/*.json"

package/types.ts

@@ -2,6 +2,8 @@
 //
 import { createRouter } from './router';
 
+export * as util from './util';
+
 // Imports
 import * as Area from './modules/area';
 import * as Asset from './modules/asset';

package/util.ts

@@ -0,0 +1 @@
+export * from '.';

package/modules/area/area.models.ts

@@ -1,15 +0,0 @@
-import * as mongo from '../../util/mongo';
-import type * as Types from './area.types';
-
-export const Area = mongo.createModel<Types.AreaDocument>('Area', {
-  type: { type: String, default: 'Zone' },
-  shortDescription: { type: String },
-  // landmarks: [{ type: mongo.Schema.Types.ObjectId, ref: 'AreaLandmark' }],
-});
-
-export const AreaLandmark = mongo.createModel<Types.AreaLandmarkDocument>('AreaLandmark', {
-  areaId: { type: mongo.Schema.Types.ObjectId, ref: 'Area' },
-});
-
-export const AreaType = mongo.createModel<Types.AreaTypeDocument>('AreaType', {});
-export const AreaNameChoice = mongo.createModel<Types.AreaNameChoiceDocument>('AreaNameChoice', {});

package/modules/area/area.router.ts

@@ -1,74 +0,0 @@
-import { z as zod } from 'zod';
-import { initTRPC } from '@trpc/server';
-import { customErrorFormatter, hasRole } from '../../util/rpc';
-import type { RouterContext } from '../../types';
-import { Area, AreaLandmark, AreaType } from './area.schema';
-import { Query, getQueryInput, inferRouterOutputs, inferRouterInputs } from '../../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({
-    getArea: procedure
-      .use(hasRole('guest', t))
-      .use(customErrorFormatter(t))
-      .input(getQueryInput(Area))
-      .query(({ input, ctx }) => (ctx.app.service.Area.getArea as any)(input, ctx)),
-
-    getAreas: procedure
-      .use(hasRole('guest', t))
-      .use(customErrorFormatter(t))
-      .input(getQueryInput(Area))
-      .query(({ input, ctx }) => (ctx.app.service.Area.getAreas as any)(input, ctx)),
-
-    saveArea: procedure
-      .use(hasRole('admin', t))
-      .use(customErrorFormatter(t))
-      .input(getQueryInput(Area))
-      .output(Area.pick({ id: true }))
-      .mutation(({ input, ctx }) => (ctx.app.service.Area.saveArea as any)(input, ctx)),
-
-    getAreaLandmark: procedure
-      .use(hasRole('guest', t))
-      .use(customErrorFormatter(t))
-      .input(z.object({ query: Query }))
-      .query(({ input, ctx }) => (ctx.app.service.Area.getAreaLandmark as any)(input, ctx)),
-
-    createAreaLandmark: procedure
-      .use(hasRole('admin', t))
-      .use(customErrorFormatter(t))
-      .input(z.object({ data: AreaLandmark.omit({ id: true }) }))
-      .mutation(({ input, ctx }) => (ctx.app.service.Area.createAreaLandmark as any)(input, ctx)),
-
-    updateAreaLandmark: procedure
-      .use(hasRole('admin', t))
-      .use(customErrorFormatter(t))
-      .input(z.object({ query: Query, data: AreaLandmark.partial() }))
-      .mutation(({ input, ctx }) => (ctx.app.service.Area.updateAreaLandmark as any)(input, ctx)),
-
-    getAreaType: procedure
-      .use(hasRole('guest', t))
-      .use(customErrorFormatter(t))
-      .input(z.object({ query: Query }))
-      .query(({ input, ctx }) => (ctx.app.service.Area.getAreaType as any)(input, ctx)),
-
-    createAreaType: procedure
-      .use(hasRole('admin', t))
-      .use(customErrorFormatter(t))
-      .input(z.object({ data: AreaType.omit({ id: true }) }))
-      .mutation(({ input, ctx }) => (ctx.app.service.Area.createAreaType as any)(input, ctx)),
-
-    updateAreaType: procedure
-      .use(hasRole('admin', t))
-      .use(customErrorFormatter(t))
-      .input(z.object({ query: Query, data: AreaType.partial() }))
-      .output(AreaType.partial())
-      .mutation(({ input, ctx }) => (ctx.app.service.Area.updateAreaType as any)(input, ctx)),
-  });
-
-export type Router = ReturnType<typeof createRouter>;
-export type RouterInput = inferRouterInputs<Router>;
-export type RouterOutput = inferRouterOutputs<Router>;

package/modules/area/area.schema.ts

@@ -1,22 +0,0 @@
-// arken/packages/node/modules/area/area.schema.ts
-//
-import { z, ObjectId, Entity } from '../../schema';
-
-export const Area = Entity.merge(
-  z.object({
-    type: z.string().default('Zone'),
-    landmarks: z.array(ObjectId).optional(),
-    shortDescription: z.string(),
-  })
-);
-
-export const AreaLandmark = Entity.merge(
-  z.object({
-    areaId: ObjectId.optional(),
-    area: ObjectId.optional(),
-  })
-);
-
-export const AreaType = Entity.merge(z.object({}));
-
-export const AreaNameChoice = Entity.merge(z.object({}));

package/modules/area/area.service.ts

@@ -1,124 +0,0 @@
-import type { Area, AreaLandmark, AreaType, RouterInput, RouterOutput, RouterContext } from './area.types';
-import { getFilter } from '../../util/api';
-import { ARXError } from '../../util/rpc';
-
-export class Service {
-  async getArea(input: RouterInput['getArea'], ctx: RouterContext): Promise<RouterOutput['getArea']> {
-    if (!input) throw new Error('Input should not be void');
-    console.log('Area.Service.getArea', input);
-
-    const filter = getFilter(input);
-    // @ts-ignore
-    const area = await ctx.app.model.Area.findOne(filter).asJSON();
-    if (!area) throw new Error('Area not found');
-
-    return area as Area;
-  }
-
-  async getAreas(input: RouterInput['getAreas'], ctx: RouterContext): Promise<RouterOutput['getAreas']> {
-    if (!input) throw new ARXError('NO_INPUT');
-
-    const filter = getFilter(input);
-
-    const limit = input.limit ?? 50;
-    const skip = input.skip ?? 0;
-
-    const [items, total] = await Promise.all([
-      // @ts-ignore
-      ctx.app.model.Area.find(filter).skip(skip).limit(limit).asJSON(),
-      ctx.app.model.Area.find(filter).countDocuments().exec(),
-    ]);
-
-    return { items, total };
-  }
-
-  async getAreaLandmark(
-    input: RouterInput['getAreaLandmark'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['getAreaLandmark']> {
-    if (!input) throw new Error('Input should not be void');
-    console.log('Area.Service.getAreaLandmark', input.query);
-
-    const filter = getFilter(input.query);
-    const areaLandmark = await ctx.app.model.AreaLandmark.findOne(filter).lean().exec();
-    if (!areaLandmark) throw new Error('AreaLandmark not found');
-
-    return areaLandmark as AreaLandmark;
-  }
-
-  async getAreaType(input: RouterInput['getAreaType'], ctx: RouterContext): Promise<RouterOutput['getAreaType']> {
-    if (!input) throw new Error('Input should not be void');
-    console.log('Area.Service.getAreaType', input.query);
-
-    const filter = getFilter(input.query);
-    const areaType = await ctx.app.model.AreaType.findOne(filter).lean().exec();
-    if (!areaType) throw new Error('AreaType not found');
-
-    return areaType as AreaType;
-  }
-
-  async saveArea(input: RouterInput['saveArea'], ctx: RouterContext): Promise<RouterOutput['saveArea']> {
-    if (!input) throw new Error('Input should not be void');
-    console.log('Area.Service.saveArea', input);
-
-    const filter = getFilter(input);
-    const area = await ctx.app.model.Area.findOneAndUpdate(filter, input.data, { new: true }).lean().exec();
-    if (!area) throw new Error('Area update failed');
-
-    return area as Area;
-  }
-
-  async createAreaLandmark(
-    input: RouterInput['createAreaLandmark'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['createAreaLandmark']> {
-    if (!input) throw new Error('Input should not be void');
-    console.log('Area.Service.createAreaLandmark', input.data);
-
-    const areaLandmark = await ctx.app.model.AreaLandmark.create(input.data);
-    return areaLandmark as AreaLandmark;
-  }
-
-  async createAreaType(
-    input: RouterInput['createAreaType'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['createAreaType']> {
-    if (!input) throw new Error('Input should not be void');
-    console.log('Area.Service.createAreaType', input.data);
-
-    const areaType = await ctx.app.model.AreaType.create(input.data);
-    return areaType as AreaType;
-  }
-
-  async updateAreaLandmark(
-    input: RouterInput['updateAreaLandmark'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['updateAreaLandmark']> {
-    if (!input) throw new Error('Input should not be void');
-    console.log('Area.Service.updateAreaLandmark', input.query, input.data);
-
-    const filter = getFilter(input.query);
-    const updatedAreaLandmark = await ctx.app.model.AreaLandmark.findOneAndUpdate(filter, input.data, { new: true })
-      .lean()
-      .exec();
-    if (!updatedAreaLandmark) throw new Error('AreaLandmark update failed');
-
-    return updatedAreaLandmark as AreaLandmark;
-  }
-
-  async updateAreaType(
-    input: RouterInput['updateAreaType'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['updateAreaType']> {
-    if (!input) throw new Error('Input should not be void');
-    console.log('Area.Service.updateAreaType', input.query, input.data);
-
-    const filter = getFilter(input.query);
-    const updatedAreaType = await ctx.app.model.AreaType.findOneAndUpdate(filter, input.data, { new: true })
-      .lean()
-      .exec();
-    if (!updatedAreaType) throw new Error('AreaType update failed');
-
-    return updatedAreaType as AreaType;
-  }
-}