@quantform/core 0.7.22 → 0.7.25

package/src/storage/in-memory/in-memory-storage.spec.ts

@@ -1,5 +1,6 @@
 import { d } from '@lib/shared';
 import { eq, gt, lt, Storage } from '@lib/storage';
+import { ns } from '@lib/use-timestamp';
 
 import { InMemoryStorage } from './in-memory-storage';
 
@@ -27,26 +28,26 @@ describe(InMemoryStorage.name, () => {
     const { sut } = fixtures;
 
     const pricing = Storage.createObject('pricing', {
-      timestamp: 'number',
+      timestamp: 'bigint',
       rate: 'decimal'
     });
 
     await sut.save(pricing, [
-      { timestamp: 1, rate: d(1) },
-      { timestamp: 2, rate: d(2) },
-      { timestamp: 3, rate: d(3) },
-      { timestamp: 4, rate: d(4) },
-      { timestamp: 5, rate: d(5) }
+      { timestamp: ns(1), rate: d(1) },
+      { timestamp: ns(2), rate: d(2) },
+      { timestamp: ns(3), rate: d(3) },
+      { timestamp: ns(4), rate: d(4) },
+      { timestamp: ns(5), rate: d(5) }
     ]);
 
     const set = await sut.query(pricing, {});
 
     expect(set).toEqual([
-      { timestamp: 1, rate: d(1) },
-      { timestamp: 2, rate: d(2) },
-      { timestamp: 3, rate: d(3) },
-      { timestamp: 4, rate: d(4) },
-      { timestamp: 5, rate: d(5) }
+      { timestamp: ns(1), rate: d(1) },
+      { timestamp: ns(2), rate: d(2) },
+      { timestamp: ns(3), rate: d(3) },
+      { timestamp: ns(4), rate: d(4) },
+      { timestamp: ns(5), rate: d(5) }
     ]);
   });
 
@@ -54,24 +55,24 @@ describe(InMemoryStorage.name, () => {
     const { sut } = fixtures;
 
     const pricing = Storage.createObject('pricing', {
-      timestamp: 'number',
+      timestamp: 'bigint',
       rate: 'decimal'
     });
 
     await sut.save(pricing, [
-      { timestamp: 1, rate: d(1) },
-      { timestamp: 2, rate: d(2) },
-      { timestamp: 3, rate: d(3) },
-      { timestamp: 4, rate: d(4) },
-      { timestamp: 5, rate: d(5) }
+      { timestamp: ns(1), rate: d(1) },
+      { timestamp: ns(2), rate: d(2) },
+      { timestamp: ns(3), rate: d(3) },
+      { timestamp: ns(4), rate: d(4) },
+      { timestamp: ns(5), rate: d(5) }
     ]);
 
     const set = await sut.query(pricing, { limit: 3 });
 
     expect(set).toEqual([
-      { timestamp: 1, rate: d(1) },
-      { timestamp: 2, rate: d(2) },
-      { timestamp: 3, rate: d(3) }
+      { timestamp: ns(1), rate: d(1) },
+      { timestamp: ns(2), rate: d(2) },
+      { timestamp: ns(3), rate: d(3) }
     ]);
   });
 
@@ -79,26 +80,26 @@ describe(InMemoryStorage.name, () => {
     const { sut } = fixtures;
 
     const pricing = Storage.createObject('pricing', {
-      timestamp: 'number',
+      timestamp: 'bigint',
       rate: 'decimal'
     });
 
     await sut.save(pricing, [
-      { timestamp: 1, rate: d(1) },
-      { timestamp: 2, rate: d(2) },
-      { timestamp: 3, rate: d(3) },
-      { timestamp: 4, rate: d(4) },
-      { timestamp: 5, rate: d(5) }
+      { timestamp: ns(1), rate: d(1) },
+      { timestamp: ns(2), rate: d(2) },
+      { timestamp: ns(3), rate: d(3) },
+      { timestamp: ns(4), rate: d(4) },
+      { timestamp: ns(5), rate: d(5) }
     ]);
 
     const set = await sut.query(pricing, { orderBy: 'DESC' });
 
     expect(set).toEqual([
-      { timestamp: 5, rate: d(5) },
-      { timestamp: 4, rate: d(4) },
-      { timestamp: 3, rate: d(3) },
-      { timestamp: 2, rate: d(2) },
-      { timestamp: 1, rate: d(1) }
+      { timestamp: ns(5), rate: d(5) },
+      { timestamp: ns(4), rate: d(4) },
+      { timestamp: ns(3), rate: d(3) },
+      { timestamp: ns(2), rate: d(2) },
+      { timestamp: ns(1), rate: d(1) }
     ]);
   });
 
@@ -106,16 +107,16 @@ describe(InMemoryStorage.name, () => {
     const { sut } = fixtures;
 
     const pricing = Storage.createObject('pricing', {
-      timestamp: 'number',
+      timestamp: 'bigint',
       rate: 'decimal'
     });
 
     await sut.save(pricing, [
-      { timestamp: 1, rate: d(1) },
-      { timestamp: 2, rate: d(2) },
-      { timestamp: 3, rate: d(3) },
-      { timestamp: 4, rate: d(4) },
-      { timestamp: 5, rate: d(5) }
+      { timestamp: ns(1), rate: d(1) },
+      { timestamp: ns(2), rate: d(2) },
+      { timestamp: ns(3), rate: d(3) },
+      { timestamp: ns(4), rate: d(4) },
+      { timestamp: ns(5), rate: d(5) }
     ]);
 
     const set = await sut.query(pricing, {
@@ -124,23 +125,23 @@ describe(InMemoryStorage.name, () => {
       }
     });
 
-    expect(set).toEqual([{ timestamp: 4, rate: d(4) }]);
+    expect(set).toEqual([{ timestamp: ns(4), rate: d(4) }]);
   });
 
   test('save and read filtered lt data', async () => {
     const { sut } = fixtures;
 
     const pricing = Storage.createObject('pricing', {
-      timestamp: 'number',
+      timestamp: 'bigint',
       rate: 'decimal'
     });
 
     await sut.save(pricing, [
-      { timestamp: 1, rate: d(1) },
-      { timestamp: 2, rate: d(2) },
-      { timestamp: 3, rate: d(3) },
-      { timestamp: 4, rate: d(4) },
-      { timestamp: 5, rate: d(5) }
+      { timestamp: ns(1), rate: d(1) },
+      { timestamp: ns(2), rate: d(2) },
+      { timestamp: ns(3), rate: d(3) },
+      { timestamp: ns(4), rate: d(4) },
+      { timestamp: ns(5), rate: d(5) }
     ]);
 
     const set = await sut.query(pricing, {
@@ -150,8 +151,8 @@ describe(InMemoryStorage.name, () => {
     });
 
     expect(set).toEqual([
-      { timestamp: 1, rate: d(1) },
-      { timestamp: 2, rate: d(2) }
+      { timestamp: ns(1), rate: d(1) },
+      { timestamp: ns(2), rate: d(2) }
     ]);
   });
 
@@ -159,16 +160,16 @@ describe(InMemoryStorage.name, () => {
     const { sut } = fixtures;
 
     const pricing = Storage.createObject('pricing', {
-      timestamp: 'number',
+      timestamp: 'bigint',
       rate: 'decimal'
     });
 
     await sut.save(pricing, [
-      { timestamp: 1, rate: d(1) },
-      { timestamp: 2, rate: d(2) },
-      { timestamp: 3, rate: d(3) },
-      { timestamp: 4, rate: d(4) },
-      { timestamp: 5, rate: d(5) }
+      { timestamp: ns(1), rate: d(1) },
+      { timestamp: ns(2), rate: d(2) },
+      { timestamp: ns(3), rate: d(3) },
+      { timestamp: ns(4), rate: d(4) },
+      { timestamp: ns(5), rate: d(5) }
     ]);
 
     const set = await sut.query(pricing, {
@@ -178,8 +179,8 @@ describe(InMemoryStorage.name, () => {
     });
 
     expect(set).toEqual([
-      { timestamp: 4, rate: d(4) },
-      { timestamp: 5, rate: d(5) }
+      { timestamp: ns(4), rate: d(4) },
+      { timestamp: ns(5), rate: d(5) }
     ]);
   });
 });

package/src/storage/in-memory/in-memory-storage.ts

@@ -29,18 +29,35 @@ export class InMemoryStorage implements Storage {
 
         switch (expression?.type) {
           case 'eq':
-            set = set.filter(it => it[prop] === expression.value);
+            set = set.filter(it => it[prop] == expression.value);
             break;
           case 'gt':
-            set = set.filter(it => +it[prop] > expression.value);
+            set = set.filter(it => {
+              const value = it[prop];
+
+              return typeof value === 'bigint'
+                ? BigInt(value) > expression.value
+                : Number(value) > Number(expression.value);
+            });
             break;
           case 'lt':
-            set = set.filter(it => +it[prop] < expression.value);
+            set = set.filter(it => {
+              const value = it[prop];
+
+              return typeof value === 'bigint'
+                ? BigInt(value) < expression.value
+                : Number(value) < Number(expression.value);
+            });
             break;
           case 'between':
-            set = set.filter(
-              it => +it[prop] > expression.min && +it[prop] < expression.max
-            );
+            set = set.filter(it => {
+              const value = it[prop];
+
+              return typeof value === 'bigint'
+                ? BigInt(value) > expression.min && BigInt(value) < expression.max
+                : Number(value) > Number(expression.min) &&
+                    Number(value) < Number(expression.max);
+            });
             break;
         }
       }
@@ -71,7 +88,7 @@ export class InMemoryStorage implements Storage {
       buffer.push(document);
     }
 
-    buffer.sort((lhs, rhs) => lhs.timestamp - rhs.timestamp);
+    buffer.sort((lhs, rhs) => Number(lhs.timestamp - rhs.timestamp));
   }
 
   clear() {

package/src/storage/storage.ts

@@ -1,17 +1,24 @@
 import { decimal } from '@lib/shared';
+import { Timestamp } from '@lib/use-timestamp';
 
-type Types = string | number | decimal;
+type Types = string | number | bigint | decimal;
 
 export const eq = <T extends Types>(value: T) => ({ type: 'eq' as const, value });
-export const gt = <T extends number>(value: T) => ({ type: 'gt' as const, value });
-export const lt = <T extends number>(value: T) => ({ type: 'lt' as const, value });
-export const between = <T extends number>(min: T, max: T) => ({
+export const gt = <T extends number | bigint>(value: T) => ({
+  type: 'gt' as const,
+  value
+});
+export const lt = <T extends number | bigint>(value: T) => ({
+  type: 'lt' as const,
+  value
+});
+export const between = <T extends number | bigint>(min: T, max: T) => ({
   type: 'between' as const,
   min,
   max
 });
 
-export type QueryObject = Record<string, Types> & { timestamp: number };
+export type QueryObject = Record<string, Types> & { timestamp: Timestamp<'ns'> };
 export type QueryObjectType<T extends QueryObject> = {
   discriminator: string;
   type: {
@@ -34,17 +41,19 @@ export type Query<T extends QueryObject> = {
   offset?: number;
 };
 
-export type QueryMappingType = 'number' | 'string' | 'decimal';
+export type QueryMappingType = 'number' | 'bigint' | 'string' | 'decimal';
 export type InferQueryObject<T> = T extends QueryObjectType<infer U>
   ? {
       [key in keyof T['type']]: T['type'][key] extends 'number'
         ? number
+        : T['type'][key] extends 'bigint'
+        ? bigint
         : T['type'][key] extends 'string'
         ? string
         : T['type'][key] extends 'decimal'
         ? decimal
         : never;
-    } & { timestamp: number }
+    } & { timestamp: Timestamp<'ns'> }
   : never;
 
 export abstract class Storage {

package/src/storage/use-cache.ts

@@ -1,13 +1,13 @@
 import { from, map, Observable, of, switchMap } from 'rxjs';
 
-import { now } from '@lib/shared';
 import { useStorage } from '@lib/storage/use-storage';
 import { dependency, useHash } from '@lib/use-hash';
+import { now } from '@lib/use-timestamp';
 
 import { eq, gt, Storage } from './storage';
 
 const object = Storage.createObject('keyValue', {
-  timestamp: 'number',
+  timestamp: 'bigint',
   forKey: 'string',
   rawJson: 'string'
 });
@@ -15,7 +15,7 @@ const object = Storage.createObject('keyValue', {
 export const useCache = <T>(
   calculateValue: Observable<T>,
   dependencies: dependency[],
-  ttl: number = 60 * 60 * 24 * 1000
+  ttl = BigInt(60 * 60 * 24 * 1000000)
 ): Observable<T> => {
   const storage = useStorage(['cache']);
   const key = useHash(dependencies);
@@ -24,7 +24,7 @@ export const useCache = <T>(
   return from(
     storage.query(object, {
       where: {
-        timestamp: gt(timestamp - ttl),
+        timestamp: gt(timestamp - BigInt(ttl)),
         forKey: eq(key)
       },
       limit: 1,

package/src/storage/use-storage.ts

@@ -1,11 +1,13 @@
 import { dependency, useHash } from '@lib/use-hash';
-import { withMemo } from '@lib/with-memo';
+import { useMemo } from '@lib/use-memo';
 
 import { useStorageFactory } from './use-storage-factory';
 
-export const useStorage = withMemo((dependencies: dependency[]) => {
-  const key = useHash(dependencies);
-  const factory = useStorageFactory();
+export function useStorage(dependencies: dependency[]) {
+  return useMemo(() => {
+    const key = useHash(dependencies);
+    const factory = useStorageFactory();
 
-  return factory.for(key);
-});
+    return factory.for(key);
+  }, [dependencies]);
+}

package/src/use-hash.spec.ts

@@ -1,13 +1,10 @@
-import { assetOf } from './asset';
-import { instrumentOf } from './instrument';
 import { dependency, useHash } from './use-hash';
 
 describe(useHash.name, () => {
   it.each<[dependency[], string]>([
-    [[assetOf('binance:btc')], 'binance:btc'],
-    [[assetOf('binance:btc'), 'test'], 'binance:btc/test'],
-    [[instrumentOf('binance:btc-usdt')], 'binance:btc-usdt'],
-    [[instrumentOf('binance:btc-usdt'), 123], 'binance:btc-usdt/123']
+    [['binance:btc'], 'binance:btc'],
+    [['binance:btc', 'test'], 'binance:btc/test'],
+    [['binance:btc-usdt', 123], 'binance:btc-usdt/123']
   ])('hash list of dependencies from %p to %p', (dependencies, hashed) => {
     const hash = useHash(dependencies);
 

package/src/use-logger.ts

@@ -1,8 +1,8 @@
 import chalk from 'chalk';
 
 import { Dependency, useContext } from './module';
-import { useTimestamp } from './use-timestamp';
-import { withMemo } from './with-memo';
+import { useMemo } from './use-memo';
+import { convert, useTimestamp } from './use-timestamp';
 
 const token = Symbol('logger');
 
@@ -28,7 +28,7 @@ export class ConsoleLoggerFactory implements ILoggerFactory {
   for(context: string, tint?: string): ILogger {
     const prefix = () =>
       `${chalk.hex(tint ?? this.colorize(context))(
-        new Date(useTimestamp()).toISOString()
+        new Date(Number(convert(useTimestamp().timestamp, 'ns', 'ms'))).toISOString()
       )} ${chalk.hex(tint ?? this.colorize(context))(context)}`;
 
     return {
@@ -69,6 +69,9 @@ export class ConsoleLoggerFactory implements ILoggerFactory {
 /**
  *
  */
-export const useLogger = withMemo((context: string, tint?: string) =>
-  useContext<ILoggerFactory>(token).for(context, tint)
-);
+export function useLogger(context: string, tint?: string) {
+  return useMemo(
+    () => useContext<ILoggerFactory>(token).for(context, tint),
+    [context, tint]
+  );
+}

package/src/use-socket.ts

@@ -2,7 +2,7 @@ import { defer, Observable, of, ReplaySubject } from 'rxjs';
 import { WebSocket } from 'ws';
 
 import { useLogger } from './use-logger';
-import { useTimestamp } from './use-timestamp';
+import { Timestamp, useTimestamp } from './use-timestamp';
 
 export function useSocket(
   url: string,
@@ -32,14 +32,14 @@ export function useSocket(
      * Observes socket events and handles connection health monitoring via ping/pong
      * @returns observable emitting message events with timestamps and parsed payloads
      */
-    watch(): Observable<{ timestamp: number; payload: unknown }> {
+    watch(): Observable<{ timestamp: Timestamp<'ns'>; payload: unknown }> {
       let isAlive = false;
       let interval: NodeJS.Timeout | undefined;
 
       return new Observable(stream => {
         socket.onmessage = it =>
           stream.next({
-            timestamp: useTimestamp(),
+            ...useTimestamp(),
             payload: JSON.parse(it.data as string)
           });
         socket.onerror = it => {
@@ -80,13 +80,13 @@ export function useSocket(
       });
     },
 
-    send(message: { payload: unknown }): Observable<{ timestamp: number }> {
+    send(message: { payload: unknown }): Observable<{ timestamp: Timestamp<'ns'> }> {
       return defer(() => {
         debug('sent', url, message.payload);
 
         socket.send(JSON.stringify(message.payload));
 
-        return of({ timestamp: useTimestamp() });
+        return of(useTimestamp());
       });
     },
 

package/src/use-timestamp.ts

@@ -2,12 +2,50 @@ import { useExecutionMode } from '@lib/use-execution-mode';
 
 import { useReplayScheduler } from './replay';
 
-export function useTimestamp() {
+export type Unit = 'ns' | 'us' | 'ms' | 's';
+
+export type Timestamp<Unit> = bigint & { readonly __unit: Unit };
+
+export function now(): Timestamp<'ns'> {
+  return process.hrtime.bigint() as Timestamp<'ns'>;
+}
+
+export const ns = (value: bigint | number): Timestamp<'ns'> =>
+  BigInt(value) as Timestamp<'ns'>;
+export const us = (value: bigint | number): Timestamp<'us'> =>
+  BigInt(value) as Timestamp<'us'>;
+export const ms = (value: bigint | number): Timestamp<'ms'> =>
+  BigInt(value) as Timestamp<'ms'>;
+export const s = (value: bigint | number): Timestamp<'s'> =>
+  BigInt(value) as Timestamp<'s'>;
+
+const factors = {
+  ns: 1n,
+  us: 1_000n,
+  ms: 1_000_000n,
+  s: 1_000_000_000n
+} as const;
+
+export function convert<F extends Unit, T extends Unit>(
+  value: Timestamp<F>,
+  from: F,
+  to: T
+): Timestamp<T> {
+  const ns = BigInt(value) * factors[from];
+
+  return BigInt(ns / factors[to]) as Timestamp<T>;
+}
+
+export function add<U extends Unit>(a: Timestamp<U>, b: Timestamp<U>): Timestamp<U> {
+  return (a + b) as Timestamp<U>;
+}
+
+export function useTimestamp(): { timestamp: Timestamp<'ns'> } {
   const { isReplay } = useExecutionMode();
 
   if (isReplay) {
-    return useReplayScheduler().timestamp();
+    return { timestamp: useReplayScheduler().timestamp() };
   }
 
-  return Date.now();
+  return { timestamp: now() };
 }

package/src/with-request.ts

@@ -3,7 +3,7 @@ import { Observable } from 'rxjs';
 import { request } from 'undici';
 
 import { useLogger } from './use-logger';
-import { useTimestamp } from './use-timestamp';
+import { Timestamp, useTimestamp } from './use-timestamp';
 
 export type RequestMethod =
   | 'GET'
@@ -35,7 +35,7 @@ export function withRequest({
 }) {
   const { error, debug } = useLogger(withRequest.name);
 
-  return new Observable<{ timestamp: number; payload: unknown }>(subscriber => {
+  return new Observable<{ timestamp: Timestamp<'ns'>; payload: unknown }>(subscriber => {
     const correlationId = randomUUID();
 
     debug('requesting', { correlationId, method, url, headers, body });
@@ -64,7 +64,7 @@ export function withRequest({
 
           subscriber.error(new RequestNetworkError(statusCode));
         } else {
-          subscriber.next({ timestamp: useTimestamp(), payload: json });
+          subscriber.next({ ...useTimestamp(), payload: json });
         }
       })
       .catch((e: Error) => {

package/lib/asset/asset.d.ts

@@ -1,41 +0,0 @@
-import { decimal } from '../shared';
-export declare const AssetSelectorSeparator = ":";
-export declare class MissingAssetError extends Error {
-    constructor(asset: AssetSelector);
-}
-/**
- * Supposed to query specific @see Asset based on string notation.
- */
-export declare class AssetSelector {
-    readonly id: string;
-    readonly name: string;
-    readonly adapterName: string;
-    constructor(name: string, adapterName: string);
-    toString(): string;
-}
-/**
- * Creates @see AssetSelector based on unified string notation.
- */
-export declare function assetOf(selector: string): AssetSelector;
-/**
- * Represents a security that you can trade or hold in your wallet.
- * For example, you can combine two trading assets to create a trading instrument.
- */
-export declare class Asset extends AssetSelector {
-    readonly scale: number;
-    readonly tickSize: decimal;
-    constructor(name: string, adapterName: string, scale: number);
-    /**
-     * Formats a number to string with fixed number of decimal places.
-     */
-    fixed(number: decimal): string;
-    /**
-     * Rounds down a number to the asset precision.
-     */
-    floor(number: decimal): decimal;
-    /**
-     * Rounds up a number to the asset precision.
-     */
-    ceil(number: decimal): decimal;
-}
-//# sourceMappingURL=asset.d.ts.map

package/lib/asset/asset.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"asset.d.ts","sourceRoot":"","sources":["../../src/asset/asset.ts"],"names":[],"mappings":"AACA,OAAO,EAAK,OAAO,EAAE,MAAM,aAAa,CAAC;AAEzC,eAAO,MAAM,sBAAsB,MAAM,CAAC;AAE1C,qBAAa,iBAAkB,SAAQ,KAAK;gBAC9B,KAAK,EAAE,aAAa;CAGjC;AAED;;GAEG;AACH,qBAAa,aAAa;IACxB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;gBAEjB,IAAI,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM;IAc7C,QAAQ;CAGT;AAED;;GAEG;AACH,wBAAgB,OAAO,CAAC,QAAQ,EAAE,MAAM,GAAG,aAAa,CAQvD;AAED;;;GAGG;AACH,qBAAa,KAAM,SAAQ,aAAa;aAGyB,KAAK,EAAE,MAAM;IAF5E,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;gBAEf,IAAI,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,EAAkB,KAAK,EAAE,MAAM;IAU5E;;OAEG;IACH,KAAK,CAAC,MAAM,EAAE,OAAO,GAAG,MAAM;IAI9B;;OAEG;IACH,KAAK,CAAC,MAAM,EAAE,OAAO,GAAG,OAAO;IAI/B;;OAEG;IACH,IAAI,CAAC,MAAM,EAAE,OAAO,GAAG,OAAO;CAG/B"}

package/lib/asset/asset.js

@@ -1,76 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Asset = exports.assetOf = exports.AssetSelector = exports.MissingAssetError = exports.AssetSelectorSeparator = void 0;
-const component_1 = require("../component");
-const shared_1 = require("../shared");
-exports.AssetSelectorSeparator = ':';
-class MissingAssetError extends Error {
-    constructor(asset) {
-        super(`Missing asset: ${asset}`);
-    }
-}
-exports.MissingAssetError = MissingAssetError;
-/**
- * Supposed to query specific @see Asset based on string notation.
- */
-class AssetSelector {
-    constructor(name, adapterName) {
-        if (!(name === null || name === void 0 ? void 0 : name.length)) {
-            throw new component_1.InvalidArgumentsError({ name });
-        }
-        if (!(adapterName === null || adapterName === void 0 ? void 0 : adapterName.length)) {
-            throw new component_1.InvalidArgumentsError({ adapterName });
-        }
-        this.name = name.toLowerCase();
-        this.adapterName = adapterName.toLowerCase();
-        this.id = `${this.adapterName}${exports.AssetSelectorSeparator}${this.name}`;
-    }
-    toString() {
-        return this.id;
-    }
-}
-exports.AssetSelector = AssetSelector;
-/**
- * Creates @see AssetSelector based on unified string notation.
- */
-function assetOf(selector) {
-    const [adapterName, name, ...rest] = selector.split(exports.AssetSelectorSeparator);
-    if (!adapterName || !name || rest.length) {
-        throw new component_1.InvalidAssetSelectorError(selector);
-    }
-    return new AssetSelector(name, adapterName);
-}
-exports.assetOf = assetOf;
-/**
- * Represents a security that you can trade or hold in your wallet.
- * For example, you can combine two trading assets to create a trading instrument.
- */
-class Asset extends AssetSelector {
-    constructor(name, adapterName, scale) {
-        super(name, adapterName);
-        this.scale = scale;
-        if (scale && (scale < 0 || Number.isNaN(scale))) {
-            throw new component_1.InvalidArgumentsError({ scale });
-        }
-        this.tickSize = (0, shared_1.d)(1.0).div(Math.pow(10, this.scale));
-    }
-    /**
-     * Formats a number to string with fixed number of decimal places.
-     */
-    fixed(number) {
-        return number.toFixed(this.scale);
-    }
-    /**
-     * Rounds down a number to the asset precision.
-     */
-    floor(number) {
-        return number.toFloor(this.scale);
-    }
-    /**
-     * Rounds up a number to the asset precision.
-     */
-    ceil(number) {
-        return number.toCeil(this.scale);
-    }
-}
-exports.Asset = Asset;

package/lib/asset/asset.spec.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=asset.spec.d.ts.map

package/lib/asset/asset.spec.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"asset.spec.d.ts","sourceRoot":"","sources":["../../src/asset/asset.spec.ts"],"names":[],"mappings":""}