@arken/node 1.5.0 → 1.5.2

package/modules/area/area.types.ts

@@ -1,26 +0,0 @@
-import { z } from 'zod';
-import * as schema from './area.schema';
-import { Document, Model } from '../../util/mongo';
-
-export type * from './area.router';
-export type * from './area.service';
-export type { RouterContext } from '../../types';
-
-export type Area = z.infer<typeof schema.Area>;
-export type AreaDocument = Area & Document;
-
-export type AreaLandmark = z.infer<typeof schema.AreaLandmark>;
-export type AreaLandmarkDocument = AreaLandmark & Document;
-
-export type AreaType = z.infer<typeof schema.AreaType>;
-export type AreaTypeDocument = AreaType & Document;
-
-export type AreaNameChoice = z.infer<typeof schema.AreaNameChoice>;
-export type AreaNameChoiceDocument = AreaNameChoice & Document;
-
-export type Mappings = {
-  Area: Model<AreaDocument>;
-  AreaLandmark: Model<AreaLandmarkDocument>;
-  AreaType: Model<AreaTypeDocument>;
-  AreaNameChoice: Model<AreaNameChoiceDocument>;
-};

package/modules/area/index.ts

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

package/modules/asset/asset.models.ts

@@ -1,59 +0,0 @@
-import * as mongo from '../../util/mongo';
-import type * as Types from './asset.types';
-
-export const AssetStandard = mongo.createModel<Types.AssetStandardDocument>(
-  'AssetStandard',
-  {
-    version: { type: String, required: false },
-    parentId: { type: mongo.Schema.Types.ObjectId, ref: 'AssetStandard', required: false },
-  },
-  {
-    virtuals: [
-      {
-        name: 'children',
-        ref: 'AssetStandard',
-        localField: '_id',
-        foreignField: 'parent',
-        justOne: false,
-      },
-    ],
-  }
-);
-
-export const Asset = mongo.createModel<Types.AssetDocument>(
-  'Asset',
-  {
-    uri: { type: String, required: true },
-    type: { type: String, maxlength: 100, required: true },
-    standards: [{ type: mongo.Schema.Types.ObjectId, ref: 'AssetStandard', required: true }],
-    licenseId: { type: mongo.Schema.Types.ObjectId, ref: 'AssetLicense' },
-    chainId: { type: mongo.Schema.Types.ObjectId, ref: 'Chain' },
-    ownerId: { type: mongo.Schema.Types.ObjectId, ref: 'Profile' }, // Added ownerId
-    // skin: { type: String },
-    // transmuteCount: { type: Number },
-    // score: { type: Number },
-  },
-  {
-    virtuals: [
-      {
-        name: 'items',
-        ref: 'Item',
-        localField: '_id',
-        foreignField: 'assetId',
-      },
-      {
-        name: 'offers',
-        ref: 'Node',
-        localField: '_id',
-        foreignField: 'fromOfferId',
-        justOne: false,
-        match: { relationKey: 'offers' },
-      },
-    ],
-  }
-);
-
-export const AssetLicense = mongo.createModel<Types.AssetLicenseDocument>('AssetLicense', {
-  value: { type: String, required: true },
-  // assets: [{ type: mongo.Schema.Types.ObjectId, ref: 'Asset' }],
-});

package/modules/asset/asset.router.ts

@@ -1,55 +0,0 @@
-// module/asset.router.ts
-
-import { z as zod } from 'zod';
-import { initTRPC, inferRouterInputs, inferRouterOutputs } from '@trpc/server';
-import { customErrorFormatter, hasRole } from '../../util/rpc';
-import type { RouterContext } from '../../types';
-import { Asset, AssetLicense } from './asset.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({
-    getAsset: procedure
-      .use(hasRole('guest', t))
-      .use(customErrorFormatter(t))
-      .input(z.object({ assetId: z.string() }))
-      .query(({ input, ctx }) => (ctx.app.service.Asset.getAsset as any)(input, ctx)),
-
-    createAsset: procedure
-      .use(hasRole('admin', t))
-      .use(customErrorFormatter(t))
-      .input(Asset)
-      .mutation(({ input, ctx }) => (ctx.app.service.Asset.createAsset as any)(input, ctx)),
-
-    updateAsset: procedure
-      .use(hasRole('admin', t))
-      .use(customErrorFormatter(t))
-      .input(z.object({ assetId: z.string(), data: Asset.partial() }))
-      .mutation(({ input, ctx }) => (ctx.app.service.Asset.updateAsset as any)(input, ctx)),
-
-    getAssetLicense: procedure
-      .use(hasRole('guest', t))
-      .use(customErrorFormatter(t))
-      .input(z.object({ assetLicenseId: z.string() }))
-      .query(({ input, ctx }) => (ctx.app.service.Asset.getAssetLicense as any)(input, ctx)),
-
-    createAssetLicense: procedure
-      .use(hasRole('admin', t))
-      .use(customErrorFormatter(t))
-      .input(AssetLicense)
-      .mutation(({ input, ctx }) => (ctx.app.service.Asset.createAssetLicense as any)(input, ctx)),
-
-    updateAssetLicense: procedure
-      .use(hasRole('admin', t))
-      .use(customErrorFormatter(t))
-      .input(z.object({ assetLicenseId: z.string(), data: AssetLicense.partial() }))
-      .mutation(({ input, ctx }) => (ctx.app.service.Asset.updateAssetLicense as any)(input, ctx)),
-  });
-
-export type Router = ReturnType<typeof createRouter>;
-export type RouterInput = inferRouterInputs<Router>;
-export type RouterOutput = inferRouterOutputs<Router>;

package/modules/asset/asset.schema.ts

@@ -1,27 +0,0 @@
-import { z, ObjectId, Entity } from '../../schema';
-
-export const AssetStandard = Entity.merge(
-  z.object({
-    version: z.string().optional(),
-    parentId: ObjectId.optional(),
-  })
-);
-
-export const Asset = Entity.merge(
-  z.object({
-    uri: z.string().min(1),
-    type: z.string().max(100).min(1),
-    standards: z.array(ObjectId),
-    licenseId: ObjectId.optional(),
-    license: ObjectId.optional(),
-    chainId: ObjectId.optional(),
-    items: z.array(ObjectId).optional(),
-  })
-);
-
-export const AssetLicense = Entity.merge(
-  z.object({
-    value: z.string().min(1),
-    assets: z.array(ObjectId).optional(),
-  })
-);

package/modules/asset/asset.service.ts

@@ -1,85 +0,0 @@
-import type { Asset, AssetLicense, Router, RouterInput, RouterOutput, RouterContext } from './asset.types';
-
-export class Service {
-  async getAsset(input: RouterInput['getAsset'], ctx: RouterContext): Promise<RouterOutput['getAsset']> {
-    if (!input) throw new Error('Input should not be void');
-    console.log('Asset.Service.getAsset', input.assetId);
-
-    const asset = await ctx.app.model.Asset.findById(input.assetId).lean().exec();
-    if (!asset) throw new Error('Asset not found');
-
-    return asset as Asset;
-  }
-
-  async getAssetLicense(
-    input: RouterInput['getAssetLicense'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['getAssetLicense']> {
-    if (!input) throw new Error('Input should not be void');
-    console.log('Asset.Service.getAssetLicense', input.assetLicenseId);
-
-    const assetLicense = await ctx.app.model.AssetLicense.findById(input.assetLicenseId).lean().exec();
-    if (!assetLicense) throw new Error('AssetLicense not found');
-
-    return assetLicense as AssetLicense;
-  }
-
-  async createAsset(input: RouterInput['createAsset'], ctx: RouterContext): Promise<RouterOutput['createAsset']> {
-    if (!input) throw new Error('Input should not be void');
-    console.log('Asset.Service.createAsset', input.uri, input.type);
-
-    const asset = await ctx.app.model.Asset.create({
-      uri: input.uri,
-      type: input.type,
-      standards: input.standards,
-      licenseId: input.licenseId,
-      chainId: input.chainId,
-    });
-
-    return asset as Asset;
-  }
-
-  async createAssetLicense(
-    input: RouterInput['createAssetLicense'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['createAssetLicense']> {
-    if (!input) throw new Error('Input should not be void');
-    console.log('Asset.Service.createAssetLicense', input.value);
-
-    const assetLicense = await ctx.app.model.AssetLicense.create({
-      value: input.value,
-      assets: input.assets,
-    });
-
-    return assetLicense as AssetLicense;
-  }
-
-  async updateAsset(input: RouterInput['updateAsset'], ctx: RouterContext): Promise<RouterOutput['updateAsset']> {
-    if (!input) throw new Error('Input should not be void');
-    console.log('Asset.Service.updateAsset', input.assetId, input.data);
-
-    const updatedAsset = await ctx.app.model.Asset.findByIdAndUpdate(input.assetId, input.data, { new: true })
-      .lean()
-      .exec();
-    if (!updatedAsset) throw new Error('Asset update failed');
-
-    return updatedAsset as Asset;
-  }
-
-  async updateAssetLicense(
-    input: RouterInput['updateAssetLicense'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['updateAssetLicense']> {
-    if (!input) throw new Error('Input should not be void');
-    console.log('Asset.Service.updateAssetLicense', input.assetLicenseId, input.data);
-
-    const updatedAssetLicense = await ctx.app.model.AssetLicense.findByIdAndUpdate(input.assetLicenseId, input.data, {
-      new: true,
-    })
-      .lean()
-      .exec();
-    if (!updatedAssetLicense) throw new Error('AssetLicense update failed');
-
-    return updatedAssetLicense as AssetLicense;
-  }
-}

package/modules/asset/asset.types.ts

@@ -1,22 +0,0 @@
-import { z } from 'zod';
-import * as schema from './asset.schema';
-import { Document, Model } from '../../util/mongo';
-
-export type * from './asset.router';
-export type * from './asset.service';
-export type { RouterContext } from '../../types';
-
-export type Asset = z.infer<typeof schema.Asset>;
-export type AssetDocument = Asset & Document;
-
-export type AssetStandard = z.infer<typeof schema.AssetStandard>;
-export type AssetStandardDocument = AssetStandard & Document;
-
-export type AssetLicense = z.infer<typeof schema.AssetLicense>;
-export type AssetLicenseDocument = AssetLicense & Document;
-
-export type Mappings = {
-  Asset: Model<AssetDocument>;
-  AssetStandard: Model<AssetStandardDocument>;
-  AssetLicense: Model<AssetLicenseDocument>;
-};

package/modules/asset/index.ts

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

package/modules/chain/chain.models.ts

@@ -1,50 +0,0 @@
-import * as mongo from '../../util/mongo';
-import type * as Types from './chain.types';
-
-export const Chain = mongo.createModel<Types.ChainDocument>('Chain', {
-  content: { type: String, required: true },
-  type: { type: String, maxlength: 100, required: true },
-});
-
-export const ChainContract = mongo.createModel<Types.ChainContractDocument>('ChainContract', {
-  chainId: { type: mongo.Schema.Types.ObjectId, ref: 'Chain', required: true },
-  content: { type: String },
-  address: { type: String },
-  type: { type: String, maxlength: 100, required: true },
-  standards: [{ type: mongo.Schema.Types.ObjectId, ref: 'AssetStandard', required: true }],
-});
-
-export const ChainToken = mongo.createModel<Types.ChainTokenDocument>(
-  'ChainToken',
-  {
-    chainId: { type: mongo.Schema.Types.ObjectId, ref: 'Chain', required: true },
-    chainContractId: { type: mongo.Schema.Types.ObjectId, ref: 'ChainContract', required: true },
-    rank: { type: Number, min: 0, default: 0 },
-    description: { type: String, trim: true },
-    address: { type: String },
-    content: { type: String },
-    decimals: { type: Number, default: 0 },
-    price: { type: Number, min: 0, default: 0 },
-    hourChange: { type: Number, default: 0 },
-    dayChange: { type: Number, default: 0 },
-    weekChange: { type: Number, default: 0 },
-    marketCap: { type: Number, min: 0, default: 0 },
-    volume: { type: Number, min: 0, default: 0 },
-    symbol: { type: String, required: true, trim: true },
-    circulatingSupply: { type: Number, min: 0, default: 0 },
-    cmcLink: { type: String, trim: true },
-    movementDown: { type: Number, min: 0, default: 0 },
-    movementUp: { type: Number, min: 0, default: 0 },
-    enteredTop100: { type: Number, min: 0, default: 0 },
-    exitedTop100: { type: Number, min: 0, default: 0 },
-    largeMoveDown: { type: Number, min: 0, default: 0 },
-  },
-  {
-    indexes: [{ applicationId: 1, symbol: 1, unique: true }],
-  }
-);
-
-export const ChainTransaction = mongo.createModel<Types.ChainTransactionDocument>('ChainTransaction', {
-  value: { type: String, required: true },
-  chainId: { type: mongo.Schema.Types.ObjectId, ref: 'Chain', required: true },
-});

package/modules/chain/chain.router.ts

@@ -1,104 +0,0 @@
-// module/chain.router.ts
-
-import { z as zod } from 'zod';
-import { initTRPC, inferRouterInputs } from '@trpc/server';
-import { customErrorFormatter, hasRole } from '../../util/rpc';
-import type { RouterContext } from '../../types';
-import { Chain, ChainContract, ChainToken, ChainTransaction } from './chain.schema';
-import { Query, getQueryInput, getQueryOutput, inferRouterOutputs } 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({
-    getChain: procedure
-      .use(hasRole('guest', t))
-      .use(customErrorFormatter(t))
-      .input(getQueryInput(Chain))
-      .output(Chain)
-      .query(({ input, ctx }) => (ctx.app.service.Chain.getChain as any)(input, ctx)),
-
-    createChain: procedure
-      .use(hasRole('admin', t))
-      .use(customErrorFormatter(t))
-      .input(getQueryInput(Chain))
-      .output(Chain.pick({ id: true }))
-      .mutation(({ input, ctx }) => (ctx.app.service.Chain.createChain as any)(input, ctx)),
-
-    updateChain: procedure
-      .use(hasRole('admin', t))
-      .use(customErrorFormatter(t))
-      .input(getQueryInput(Chain))
-      .output(Chain.pick({ id: true }))
-      .mutation(({ input, ctx }) => (ctx.app.service.Chain.updateChain as any)(input, ctx)),
-
-    getChainContract: procedure
-      .use(hasRole('guest', t))
-      .use(customErrorFormatter(t))
-      .input(getQueryInput(ChainContract))
-      .output(ChainContract)
-      .query(({ input, ctx }) => (ctx.app.service.Chain.getChainContract as any)(input, ctx)),
-
-    createChainContract: procedure
-      .use(hasRole('admin', t))
-      .use(customErrorFormatter(t))
-      .input(getQueryInput(ChainContract))
-      .output(ChainContract.pick({ id: true }))
-      .mutation(({ input, ctx }) => (ctx.app.service.Chain.createChainContract as any)(input, ctx)),
-
-    updateChainContract: procedure
-      .use(hasRole('admin', t))
-      .use(customErrorFormatter(t))
-      .input(getQueryInput(ChainContract))
-      .output(ChainContract.pick({ id: true }))
-      .mutation(({ input, ctx }) => (ctx.app.service.Chain.updateChainContract as any)(input, ctx)),
-
-    getChainToken: procedure
-      .use(hasRole('guest', t))
-      .use(customErrorFormatter(t))
-      .input(getQueryInput(ChainToken))
-      .output(ChainToken)
-      .query(({ input, ctx }) => (ctx.app.service.Chain.getChainToken as any)(input, ctx)),
-
-    createChainToken: procedure
-      .use(hasRole('admin', t))
-      .use(customErrorFormatter(t))
-      .input(getQueryInput(ChainToken))
-      .output(ChainToken.pick({ id: true }))
-      .mutation(({ input, ctx }) => (ctx.app.service.Chain.createChainToken as any)(input, ctx)),
-
-    updateChainToken: procedure
-      .use(hasRole('admin', t))
-      .use(customErrorFormatter(t))
-      .input(getQueryInput(ChainToken))
-      .output(ChainToken.pick({ id: true }))
-      .mutation(({ input, ctx }) => (ctx.app.service.Chain.updateChainToken as any)(input, ctx)),
-
-    getChainTransaction: procedure
-      .use(hasRole('guest', t))
-      .use(customErrorFormatter(t))
-      .input(getQueryInput(ChainTransaction))
-      .output(ChainTransaction)
-      .query(({ input, ctx }) => (ctx.app.service.Chain.getChainTransaction as any)(input, ctx)),
-
-    createChainTransaction: procedure
-      .use(hasRole('admin', t))
-      .use(customErrorFormatter(t))
-      .input(getQueryInput(ChainTransaction))
-      .output(ChainTransaction.pick({ id: true }))
-      .mutation(({ input, ctx }) => (ctx.app.service.Chain.createChainTransaction as any)(input, ctx)),
-
-    updateChainTransaction: procedure
-      .use(hasRole('admin', t))
-      .use(customErrorFormatter(t))
-      .input(getQueryInput(ChainTransaction))
-      .output(ChainTransaction.pick({ id: true }))
-      .mutation(({ input, ctx }) => (ctx.app.service.Chain.updateChainTransaction as any)(input, ctx)),
-  });
-
-export type Router = ReturnType<typeof createRouter>;
-export type RouterInput = inferRouterInputs<Router>;
-export type RouterOutput = inferRouterOutputs<Router>;

package/modules/chain/chain.schema.ts

@@ -1,52 +0,0 @@
-import { z, ObjectId, Entity } from '../../schema';
-
-export const Chain = Entity.merge(
-  z.object({
-    content: z.string().min(1),
-    type: z.string().max(100).min(1),
-    standard: z.string().max(100).min(1),
-  })
-);
-
-export const ChainContract = Entity.merge(
-  z.object({
-    chainId: ObjectId,
-    content: z.string().min(1).optional(),
-    address: z.string().max(100),
-    type: z.string().max(100).min(1),
-    standards: z.array(ObjectId),
-  })
-);
-
-export const ChainToken = Entity.merge(
-  z.object({
-    chainId: ObjectId,
-    chainContractId: ObjectId,
-    address: z.string().max(100), // TODO: validate address?
-    decimals: z.number().optional(),
-    rank: z.number().optional(),
-    description: z.string().optional(),
-    content: z.string().min(1).optional(),
-    price: z.number().optional(),
-    hourChange: z.number().optional(),
-    dayChange: z.number().optional(),
-    weekChange: z.number().optional(),
-    marketCap: z.number().optional(),
-    volume: z.number().optional(),
-    symbol: z.string().min(1),
-    circulatingSupply: z.number().optional(),
-    cmcLink: z.string().optional(),
-    movementDown: z.number().optional(),
-    movementUp: z.number().optional(),
-    enteredTop100: z.number().optional(),
-    exitedTop100: z.number().optional(),
-    largeMoveDown: z.number().optional(),
-  })
-);
-
-export const ChainTransaction = Entity.merge(
-  z.object({
-    value: z.string().min(1),
-    chainId: ObjectId,
-  })
-);

package/modules/chain/chain.service.ts

@@ -1,167 +0,0 @@
-import type {
-  Chain,
-  ChainContract,
-  ChainToken,
-  ChainTransaction,
-  Router,
-  RouterInput,
-  RouterOutput,
-  RouterContext,
-} from './chain.types';
-import { ARXError } from '../../util/rpc';
-import { getFilter } from '../../util/api';
-
-export class Service {
-  async getChain(input: RouterInput['getChain'], ctx: RouterContext): Promise<RouterOutput['getChain']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    console.log('Chain.Service.getChain', input);
-
-    const chain = await ctx.app.model.Chain.findOne(getFilter(input)).lean().exec();
-    if (!chain) throw new Error('Chain not found');
-
-    return chain as Chain;
-  }
-
-  async getChainContract(
-    input: RouterInput['getChainContract'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['getChainContract']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    console.log('Chain.Service.getChainContract', input);
-
-    const chainContract = await ctx.app.model.ChainContract.findOne(getFilter(input)).lean().exec();
-    if (!chainContract) throw new Error('ChainContract not found');
-
-    return chainContract as ChainContract;
-  }
-
-  async getChainToken(input: RouterInput['getChainToken'], ctx: RouterContext): Promise<RouterOutput['getChainToken']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    console.log('Chain.Service.getChainToken', input);
-
-    const chainToken = await ctx.app.model.ChainToken.findOne(getFilter(input)).lean().exec();
-    if (!chainToken) throw new Error('ChainToken not found');
-
-    return chainToken as ChainToken;
-  }
-
-  async getChainTransaction(
-    input: RouterInput['getChainTransaction'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['getChainTransaction']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    console.log('Chain.Service.getChainTransaction', input);
-
-    const chainTransaction = await ctx.app.model.ChainTransaction.findOne(getFilter(input)).lean().exec();
-    if (!chainTransaction) throw new Error('ChainTransaction not found');
-
-    return chainTransaction as ChainTransaction;
-  }
-
-  async createChain(input: RouterInput['createChain'], ctx: RouterContext): Promise<RouterOutput['createChain']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    console.log('Chain.Service.createChain', input);
-
-    const chain = await ctx.app.model.Chain.create(input);
-
-    return chain as Chain;
-  }
-
-  async createChainContract(
-    input: RouterInput['createChainContract'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['createChainContract']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    console.log('Chain.Service.createChainContract', input);
-
-    const chainContract = await ctx.app.model.ChainContract.create(input);
-
-    return chainContract as ChainContract;
-  }
-
-  async createChainToken(
-    input: RouterInput['createChainToken'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['createChainToken']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    console.log('Chain.Service.createChainToken', input);
-
-    const chainToken = await ctx.app.model.ChainToken.create(input);
-
-    return chainToken as ChainToken;
-  }
-
-  async createChainTransaction(
-    input: RouterInput['createChainTransaction'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['createChainTransaction']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    console.log('Chain.Service.createChainTransaction', input);
-
-    const chainTransaction = await ctx.app.model.ChainToken.create(input);
-
-    return chainTransaction as ChainTransaction;
-  }
-
-  async updateChain(input: RouterInput['updateChain'], ctx: RouterContext): Promise<RouterOutput['updateChain']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    console.log('Chain.Service.updateChain', input);
-
-    const updatedChain = await ctx.app.model.Game.findByIdAndUpdate(input.where.id.equals, { new: true }).lean().exec();
-    if (!updatedChain) throw new Error('Chain update failed');
-
-    return updatedChain as Chain;
-  }
-
-  async updateChainContract(
-    input: RouterInput['updateChainContract'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['updateChainContract']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    console.log('Chain.Service.updateChainContract', input);
-
-    const updatedChainContract = await ctx.app.model.ChainContract.findByIdAndUpdate(input.where.id.equals, {
-      new: true,
-    })
-      .lean()
-      .exec();
-
-    if (!updatedChainContract) throw new Error('ChainContract update failed');
-
-    return updatedChainContract as ChainContract;
-  }
-
-  async updateChainToken(
-    input: RouterInput['updateChainToken'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['updateChainToken']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    console.log('Chain.Service.updateChainToken', input);
-
-    const updatedChainToken = await ctx.app.model.ChainToken.findByIdAndUpdate(input.where.id.equals, { new: true })
-      .lean()
-      .exec();
-
-    if (!updatedChainToken) throw new Error('ChainToken update failed');
-
-    return updatedChainToken as ChainToken;
-  }
-
-  async updateChainTransaction(
-    input: RouterInput['updateChainTransaction'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['updateChainTransaction']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    console.log('Chain.Service.updateChainTransaction', input);
-
-    const updatedChainTransaction = await ctx.app.model.ChainTransaction.findByIdAndUpdate(input.where.id.equals, {
-      new: true,
-    })
-      .lean()
-      .exec();
-
-    if (!updatedChainTransaction) throw new Error('ChainTransaction update failed');
-
-    return updatedChainTransaction as ChainTransaction;
-  }
-}