@xyo-network/xl1-protocol 1.4.1 → 1.4.3

package/src/transaction/TransactionFeesFields.ts

@@ -1,9 +1,7 @@
 import type { Hex } from '@xylabs/hex'
 
-import {
-  AttoXL1,
-  xl1ConvertFactor,
-} from '../xl1/index.ts'
+import type { AttoXL1 } from '../xl1/index.ts'
+import { MicroXL1 } from '../xl1/index.ts'
 
 export interface TransactionFeesBigInt {
   base: AttoXL1
@@ -21,15 +19,15 @@ export interface TransactionFeesFields {
 }
 
 export const minTransactionFees: TransactionFeesBigInt = {
-  base: AttoXL1(1000n * xl1ConvertFactor('micro')),
-  gasPrice: AttoXL1(1n * xl1ConvertFactor('micro')),
-  gasLimit: AttoXL1(1000n * xl1ConvertFactor('micro')),
-  priority: AttoXL1(0n * xl1ConvertFactor('micro')),
+  base: MicroXL1(1000n).toAtto(),
+  gasPrice: MicroXL1(1n).toAtto(),
+  gasLimit: MicroXL1(1000n).toAtto(),
+  priority: MicroXL1(0n).toAtto(),
 } as const
 
 export const defaultTransactionFees: TransactionFeesBigInt = {
   base: minTransactionFees.base,
-  gasPrice: AttoXL1(10n * xl1ConvertFactor('micro')),
-  gasLimit: AttoXL1(1_000_000n * xl1ConvertFactor('micro')),
-  priority: AttoXL1(0n * xl1ConvertFactor('micro')),
+  gasPrice: MicroXL1(10n).toAtto(),
+  gasLimit: MicroXL1(1_000_000n).toAtto(),
+  priority: minTransactionFees.priority,
 } as const

package/src/xl1/XL1.ts

@@ -6,17 +6,103 @@ export type PicoXL1 = bigint & { readonly _tag: 'PicoXL1' } // 1e-6 [XL1 * 1e12
 export type FemtoXL1 = bigint & { readonly _tag: 'FemtoXL1' } // 1e-3 [XL1 * 1e15 = femtoXL1] [femtoXL1 / 1e15 = XL1]
 export type AttoXL1 = bigint & { readonly _tag: 'AttoXL1' } // 1e-0 [XL1 * 1e18 = attoXL1] [attoXL1 / 1e18 = XL1]
 
-export type TypingFunc<T extends bigint> = (value: bigint) => T
+type XL1Units = 'xl1' | 'milli' | 'micro' | 'nano' | 'pico' | 'femto' | 'atto'
 
-export const XL1: TypingFunc<XL1> = (value: bigint): XL1 => value as XL1
-export const MilliXL1: TypingFunc<MilliXL1> = (value: bigint): MilliXL1 => value as MilliXL1
-export const MicroXL1: TypingFunc<MicroXL1> = (value: bigint): MicroXL1 => value as MicroXL1
-export const NanoXL1: TypingFunc<NanoXL1> = (value: bigint): NanoXL1 => value as NanoXL1
-export const PicoXL1: TypingFunc<PicoXL1> = (value: bigint): PicoXL1 => value as PicoXL1
-export const FemtoXL1: TypingFunc<FemtoXL1> = (value: bigint): FemtoXL1 => value as FemtoXL1
-export const AttoXL1: TypingFunc<AttoXL1> = (value: bigint): AttoXL1 => value as AttoXL1
+export type TypingFunc<T extends bigint> = {
+  (value: bigint): T
+  toAtto: () => AttoXL1
+}
 
-type XL1Units = 'xl1' | 'milli' | 'micro' | 'nano' | 'pico' | 'femto' | 'atto'
+export function XL1(value: bigint): XL1 & { toAtto(): AttoXL1 } {
+  const xl1Value = value as XL1
+
+  return new Proxy(xl1Value, {
+    get(target, prop) {
+      if (prop === 'toAtto') {
+        return () => AttoXL1(target * AttoXL1ConvertFactor.xl1)
+      }
+      return Reflect.get(target, prop)
+    },
+  }) as XL1 & { toAtto(): AttoXL1 }
+}
+
+export function MilliXL1(value: bigint): MilliXL1 & { toAtto(): AttoXL1 } {
+  const xl1Value = value as MilliXL1
+
+  return new Proxy(xl1Value, {
+    get(target, prop) {
+      if (prop === 'toAtto') {
+        return () => AttoXL1(target * AttoXL1ConvertFactor.milli)
+      }
+      return Reflect.get(target, prop)
+    },
+  }) as MilliXL1 & { toAtto(): AttoXL1 }
+}
+
+export function MicroXL1(value: bigint): MicroXL1 & { toAtto(): AttoXL1 } {
+  const xl1Value = value as MicroXL1
+
+  return new Proxy(xl1Value, {
+    get(target, prop) {
+      if (prop === 'toAtto') {
+        return () => AttoXL1(target * AttoXL1ConvertFactor.micro)
+      }
+      return Reflect.get(target, prop)
+    },
+  }) as MicroXL1 & { toAtto(): AttoXL1 }
+}
+
+export function NanoXL1(value: bigint): NanoXL1 & { toAtto(): AttoXL1 } {
+  const xl1Value = value as NanoXL1
+
+  return new Proxy(xl1Value, {
+    get(target, prop) {
+      if (prop === 'toAtto') {
+        return () => AttoXL1(target * AttoXL1ConvertFactor.nano)
+      }
+      return Reflect.get(target, prop)
+    },
+  }) as NanoXL1 & { toAtto(): AttoXL1 }
+}
+
+export function PicoXL1(value: bigint): PicoXL1 & { toAtto(): AttoXL1 } {
+  const xl1Value = value as PicoXL1
+
+  return new Proxy(xl1Value, {
+    get(target, prop) {
+      if (prop === 'toAtto') {
+        return () => AttoXL1(target * AttoXL1ConvertFactor.pico)
+      }
+      return Reflect.get(target, prop)
+    },
+  }) as PicoXL1 & { toAtto(): AttoXL1 }
+}
+
+export function FemtoXL1(value: bigint): FemtoXL1 & { toAtto(): AttoXL1 } {
+  const xl1Value = value as FemtoXL1
+
+  return new Proxy(xl1Value, {
+    get(target, prop) {
+      if (prop === 'toAtto') {
+        return () => AttoXL1(target * AttoXL1ConvertFactor.femto)
+      }
+      return Reflect.get(target, prop)
+    },
+  }) as FemtoXL1 & { toAtto(): AttoXL1 }
+}
+
+export function AttoXL1(value: bigint): AttoXL1 & { toAtto(): AttoXL1 } {
+  const xl1Value = value as AttoXL1
+
+  return new Proxy(xl1Value, {
+    get(target, prop) {
+      if (prop === 'toAtto') {
+        return () => AttoXL1(target * AttoXL1ConvertFactor.atto)
+      }
+      return Reflect.get(target, prop)
+    },
+  }) as AttoXL1 & { toAtto(): AttoXL1 }
+}
 
 /** @deprecated use XL1Places and xl1ConvertFactor(unit) instead */
 export const XL1ConvertDict: Record<XL1Units, number> = {
@@ -39,6 +125,21 @@ export const XL1Places: Record<XL1Units, bigint> = {
   atto: 0n,
 } as const
 
+/**
+ * Convert factor by which a respective unit is multiplied to convert it to AttoXL1 or
+ * by which AttoXL1 is divided to convert it to respective unit is multiplied.
+ */
+export const AttoXL1ConvertFactor: Record<XL1Units, bigint> = {
+  xl1: 10n ** XL1Places.xl1,
+  milli: 10n ** XL1Places.milli,
+  micro: 10n ** XL1Places.micro,
+  nano: 10n ** XL1Places.nano,
+  pico: 10n ** XL1Places.pico,
+  femto: 10n ** XL1Places.femto,
+  atto: 10n ** XL1Places.atto,
+} as const
+
+/** @deprecated use AttoXL1ConvertFactor instead */
 export function xl1ConvertFactor(unit: XL1Units) {
   return 10n ** XL1Places[unit]
 }