@xyo-network/xl1-protocol-model 1.26.1

package/src/transaction/TransactionBoundWitness.ts

@@ -0,0 +1,187 @@
+import {
+  AddressZod,
+  zodAsFactory, zodIsFactory, zodToFactory,
+} from '@xylabs/sdk-js'
+import {
+  BoundWitnessZod, HashMetaZod, SignedBoundWitnessZod, StorageMetaZod,
+  UnsignedBoundWitnessZod,
+  WithHashMetaZod,
+  WithStorageMetaZod,
+} from '@xyo-network/sdk-js'
+import { z } from 'zod'
+
+import { XL1BlockNumberZod } from '../BlockNumber/index.ts'
+import { ChainZod } from '../chain/index.ts'
+import { TransactionFeesHexZod } from './TransactionFees.ts'
+
+/** BlockStartZod constant. */
+export const BlockStartZod = z.object({ nbf: XL1BlockNumberZod })
+/** BlockEndZod constant. */
+export const BlockEndZod = z.object({ exp: XL1BlockNumberZod })
+/** BlockDurationZod constant. */
+export const BlockDurationZod = z.object({ nbf: XL1BlockNumberZod, exp: XL1BlockNumberZod })
+/** BlockScriptsZod constant. */
+export const BlockScriptsZod = z.object({ script: z.array(z.string()).optional() })
+
+/** TransactionFeesZod constant. */
+export const TransactionFeesZod = z.object({ fees: TransactionFeesHexZod })
+
+/** TransactionBoundWitnessIdentityFields constant. */
+export const TransactionBoundWitnessIdentityFields = z.object({ chain: ChainZod, from: AddressZod })
+
+/** TransactionBoundWitnessFieldsZod constant. */
+export const TransactionBoundWitnessFieldsZod = z.object()
+  .safeExtend(BlockDurationZod.shape)
+  .safeExtend(TransactionFeesZod.shape)
+  .safeExtend(TransactionBoundWitnessIdentityFields.shape)
+  .safeExtend(BlockScriptsZod.shape)
+
+/** TransactionBoundWitnessFields type. */
+export type TransactionBoundWitnessFields = z.infer<typeof TransactionBoundWitnessFieldsZod>
+
+/** TransactionBoundWitnessZod constant. */
+export const TransactionBoundWitnessZod = BoundWitnessZod
+  .safeExtend(TransactionBoundWitnessFieldsZod.shape)
+
+/** TransactionBoundWitness type. */
+export type TransactionBoundWitness = z.infer<typeof TransactionBoundWitnessZod>
+
+/** Type guard that checks if a value is a valid TransactionBoundWitness. */
+export const isTransactionBoundWitness = zodIsFactory(TransactionBoundWitnessZod)
+/** Converts a value to TransactionBoundWitness, throwing if invalid. */
+export const asTransactionBoundWitness = zodAsFactory(TransactionBoundWitnessZod, 'asTransactionBoundWitness')
+/** toTransactionBoundWitness constant. */
+export const toTransactionBoundWitness = zodToFactory(TransactionBoundWitnessZod, 'toTransactionBoundWitness')
+
+/** TransactionBoundWitnessWithHashMetaZod constant. */
+export const TransactionBoundWitnessWithHashMetaZod = TransactionBoundWitnessZod
+  .safeExtend(HashMetaZod.shape)
+
+/** TransactionBoundWitnessWithHashMeta type. */
+export type TransactionBoundWitnessWithHashMeta = z.infer<typeof TransactionBoundWitnessWithHashMetaZod>
+
+/** Type guard that checks if a value is a valid TransactionBoundWitnessWithHashMeta. */
+export const isTransactionBoundWitnessWithHashMeta = zodIsFactory(TransactionBoundWitnessWithHashMetaZod)
+/** Converts a value to TransactionBoundWitnessWithHashMeta, throwing if invalid. */
+export const asTransactionBoundWitnessWithHashMeta = zodAsFactory(TransactionBoundWitnessWithHashMetaZod, 'asTransactionBoundWitnessWithHashMeta')
+/** toTransactionBoundWitnessWithHashMeta constant. */
+export const toTransactionBoundWitnessWithHashMeta = zodToFactory(TransactionBoundWitnessWithHashMetaZod, 'toTransactionBoundWitnessWithHashMeta')
+
+/** TransactionBoundWitnessWithStorageMetaZod constant. */
+export const TransactionBoundWitnessWithStorageMetaZod = TransactionBoundWitnessZod
+  .safeExtend(StorageMetaZod.shape)
+
+/** TransactionBoundWitnessWithStorageMeta type. */
+export type TransactionBoundWitnessWithStorageMeta = z.infer<typeof TransactionBoundWitnessWithStorageMetaZod>
+
+/** Type guard that checks if a value is a valid TransactionBoundWitnessWithStorageMeta. */
+export const isTransactionBoundWitnessWithStorageMeta = zodIsFactory(TransactionBoundWitnessWithStorageMetaZod)
+/** Converts a value to TransactionBoundWitnessWithStorageMeta, throwing if invalid. */
+export const asTransactionBoundWitnessWithStorageMeta = zodAsFactory(TransactionBoundWitnessWithStorageMetaZod, 'asTransactionBoundWitnessWithStorageMeta')
+/** toTransactionBoundWitnessWithStorageMeta constant. */
+export const toTransactionBoundWitnessWithStorageMeta = zodToFactory(TransactionBoundWitnessWithStorageMetaZod, 'toTransactionBoundWitnessWithStorageMeta')
+
+/** UnsignedTransactionBoundWitnessZod constant. */
+export const UnsignedTransactionBoundWitnessZod = UnsignedBoundWitnessZod
+  .safeExtend(TransactionBoundWitnessFieldsZod.shape)
+
+/** UnsignedTransactionBoundWitness type. */
+export type UnsignedTransactionBoundWitness = z.infer<typeof UnsignedTransactionBoundWitnessZod>
+
+/** Type guard that checks if a value is a valid UnsignedTransactionBoundWitness. */
+export const isUnsignedTransactionBoundWitness = zodIsFactory(UnsignedTransactionBoundWitnessZod)
+/** Converts a value to UnsignedTransactionBoundWitness, throwing if invalid. */
+export const asUnsignedTransactionBoundWitness = zodAsFactory(UnsignedTransactionBoundWitnessZod, 'asUnsignedTransactionBoundWitness')
+/** toUnsignedTransactionBoundWitness constant. */
+export const toUnsignedTransactionBoundWitness = zodToFactory(UnsignedTransactionBoundWitnessZod, 'toUnsignedTransactionBoundWitness')
+
+/** UnsignedTransactionBoundWitnessWithHashMetaZod constant. */
+export const UnsignedTransactionBoundWitnessWithHashMetaZod = UnsignedTransactionBoundWitnessZod.safeExtend(HashMetaZod.shape)
+
+/** UnsignedTransactionBoundWitnessWithHashMeta type. */
+export type UnsignedTransactionBoundWitnessWithHashMeta = z.infer<typeof UnsignedTransactionBoundWitnessWithHashMetaZod>
+
+/** Type guard that checks if a value is a valid UnsignedTransactionBoundWitnessWithHashMeta. */
+export const isUnsignedTransactionBoundWitnessWithHashMeta = zodIsFactory(UnsignedTransactionBoundWitnessWithHashMetaZod)
+/** Converts a value to UnsignedTransactionBoundWitnessWithHashMeta, throwing if invalid. */
+export const asUnsignedTransactionBoundWitnessWithHashMeta = zodAsFactory(
+  UnsignedTransactionBoundWitnessWithHashMetaZod,
+  'asUnsignedTransactionBoundWitnessWithHashMeta',
+)
+/** toUnsignedTransactionBoundWitnessWithHashMeta constant. */
+export const toUnsignedTransactionBoundWitnessWithHashMeta = zodToFactory(
+  UnsignedTransactionBoundWitnessWithHashMetaZod,
+  'toUnsignedTransactionBoundWitnessWithHashMeta',
+)
+
+/** UnsignedTransactionBoundWitnessWithStorageMetaZod constant. */
+export const UnsignedTransactionBoundWitnessWithStorageMetaZod = UnsignedTransactionBoundWitnessZod
+  .safeExtend(StorageMetaZod.shape)
+
+/** UnsignedTransactionBoundWitnessWithStorageMeta type. */
+export type UnsignedTransactionBoundWitnessWithStorageMeta = z.infer<typeof UnsignedTransactionBoundWitnessWithStorageMetaZod>
+
+/** Type guard that checks if a value is a valid UnsignedTransactionBoundWitnessWithStorageMeta. */
+export const isUnsignedTransactionBoundWitnessWithStorageMeta = zodIsFactory(UnsignedTransactionBoundWitnessWithStorageMetaZod)
+/** Converts a value to UnsignedTransactionBoundWitnessWithStorageMeta, throwing if invalid. */
+export const asUnsignedTransactionBoundWitnessWithStorageMeta = zodAsFactory(
+  UnsignedTransactionBoundWitnessWithStorageMetaZod,
+  'asUnsignedTransactionBoundWitnessWithStorageMeta',
+)
+/** toUnsignedTransactionBoundWitnessWithStorageMeta constant. */
+export const toUnsignedTransactionBoundWitnessWithStorageMeta = zodToFactory(
+  UnsignedTransactionBoundWitnessWithStorageMetaZod,
+  'toUnsignedTransactionBoundWitnessWithStorageMeta',
+)
+
+/** SignedTransactionBoundWitnessZod constant. */
+export const SignedTransactionBoundWitnessZod = SignedBoundWitnessZod
+  .safeExtend(TransactionBoundWitnessFieldsZod.shape)
+
+/** SignedTransactionBoundWitness type. */
+export type SignedTransactionBoundWitness = z.infer<typeof SignedTransactionBoundWitnessZod>
+
+/** Type guard that checks if a value is a valid SignedTransactionBoundWitness. */
+export const isSignedTransactionBoundWitness = zodIsFactory(SignedTransactionBoundWitnessZod)
+/** Converts a value to SignedTransactionBoundWitness, throwing if invalid. */
+export const asSignedTransactionBoundWitness = zodAsFactory(SignedTransactionBoundWitnessZod, 'asSignedTransactionBoundWitness')
+/** toSignedTransactionBoundWitness constant. */
+export const toSignedTransactionBoundWitness = zodToFactory(SignedTransactionBoundWitnessZod, 'toSignedTransactionBoundWitness')
+
+/** SignedTransactionBoundWitnessWithHashMetaZod constant. */
+export const SignedTransactionBoundWitnessWithHashMetaZod = WithHashMetaZod(SignedTransactionBoundWitnessZod)
+
+/** SignedTransactionBoundWitnessWithHashMeta type. */
+export type SignedTransactionBoundWitnessWithHashMeta = z.infer<typeof SignedTransactionBoundWitnessWithHashMetaZod>
+
+/** Type guard that checks if a value is a valid SignedTransactionBoundWitnessWithHashMeta. */
+export const isSignedTransactionBoundWitnessWithHashMeta = zodIsFactory(SignedTransactionBoundWitnessWithHashMetaZod)
+/** Converts a value to SignedTransactionBoundWitnessWithHashMeta, throwing if invalid. */
+export const asSignedTransactionBoundWitnessWithHashMeta = zodAsFactory(
+  SignedTransactionBoundWitnessWithHashMetaZod,
+  'asSignedTransactionBoundWitnessWithHashMeta',
+)
+/** toSignedTransactionBoundWitnessWithHashMeta constant. */
+export const toSignedTransactionBoundWitnessWithHashMeta = zodToFactory(
+  SignedTransactionBoundWitnessWithHashMetaZod,
+  'toSignedTransactionBoundWitnessWithHashMeta',
+)
+
+/** SignedTransactionBoundWitnessWithStorageMetaZod constant. */
+export const SignedTransactionBoundWitnessWithStorageMetaZod = WithStorageMetaZod(SignedTransactionBoundWitnessZod)
+
+/** SignedTransactionBoundWitnessWithStorageMeta type. */
+export type SignedTransactionBoundWitnessWithStorageMeta = z.infer<typeof SignedTransactionBoundWitnessWithStorageMetaZod>
+
+/** Type guard that checks if a value is a valid SignedTransactionBoundWitnessWithStorageMeta. */
+export const isSignedTransactionBoundWitnessWithStorageMeta = zodIsFactory(SignedTransactionBoundWitnessWithStorageMetaZod)
+/** Converts a value to SignedTransactionBoundWitnessWithStorageMeta, throwing if invalid. */
+export const asSignedTransactionBoundWitnessWithStorageMeta = zodAsFactory(
+  SignedTransactionBoundWitnessWithStorageMetaZod,
+  'asSignedTransactionBoundWitnessWithStorageMeta',
+)
+/** toSignedTransactionBoundWitnessWithStorageMeta constant. */
+export const toSignedTransactionBoundWitnessWithStorageMeta = zodToFactory(
+  SignedTransactionBoundWitnessWithStorageMetaZod,
+  'toSignedTransactionBoundWitnessWithStorageMeta',
+)

package/src/transaction/TransactionFees.ts

@@ -0,0 +1,73 @@
+import {
+  BigIntToJsonZod, HexZod, JsonToBigIntZod,
+  zodAsFactory, zodIsFactory, zodToFactory,
+} from '@xylabs/sdk-js'
+import { z } from 'zod'
+
+import { asAttoXL1 } from '../xl1/index.ts'
+
+/** AttoZod constant. */
+export const AttoZod = z.bigint()
+/** JsonToAttoZod constant. */
+export const JsonToAttoZod = JsonToBigIntZod.transform(v => asAttoXL1(v))
+
+/** AttoToJsonZod constant. */
+
+/** TransactionFeesHexZod constant. */
+export const TransactionFeesHexZod = z.object({
+  base: HexZod,
+  gasLimit: HexZod,
+  gasPrice: HexZod,
+  priority: HexZod,
+})
+
+/** TransactionFeesHex type. */
+export type TransactionFeesHex = z.infer<typeof TransactionFeesHexZod>
+
+/** Type guard that checks if a value is a valid TransactionFeesHex. */
+export const isTransactionFeesHex = zodIsFactory(TransactionFeesHexZod)
+/** Converts a value to TransactionFeesHex, throwing if invalid. */
+export const asTransactionFeesHex = zodAsFactory(TransactionFeesHexZod, 'asTransactionFeesHex')
+/** toTransactionFeesHex constant. */
+export const toTransactionFeesHex = zodToFactory(TransactionFeesHexZod, 'toTransactionFeesHex')
+
+/** TransactionFeesBigIntZod constant. */
+export const TransactionFeesBigIntZod = z.object({
+  base: AttoZod,
+  gasLimit: AttoZod,
+  gasPrice: AttoZod,
+  priority: AttoZod,
+})
+
+/** TransactionFeesBigInt type. */
+export type TransactionFeesBigInt = z.infer<typeof TransactionFeesBigIntZod>
+
+/** Type guard that checks if a value is a valid TransactionFeesBigInt. */
+export const isTransactionFeesBigInt = zodIsFactory(TransactionFeesBigIntZod)
+/** Converts a value to TransactionFeesBigInt, throwing if invalid. */
+export const asTransactionFeesBigInt = zodAsFactory(TransactionFeesBigIntZod, 'asTransactionFeesBigInt')
+/** toTransactionFeesBigInt constant. */
+export const toTransactionFeesBigInt = zodToFactory(TransactionFeesBigIntZod, 'toTransactionFeesBigInt')
+
+/** TransactionFeesJsonToBigIntZod constant. */
+export const TransactionFeesJsonToBigIntZod = TransactionFeesHexZod.transform(val => ({
+  base: JsonToBigIntZod.parse(val.base),
+  gasLimit: JsonToBigIntZod.parse(val.gasLimit),
+  gasPrice: JsonToBigIntZod.parse(val.gasPrice),
+  priority: JsonToBigIntZod.parse(val.priority),
+}))
+
+/** TransactionFeesBigIntToJsonZod constant. */
+export const TransactionFeesBigIntToJsonZod = TransactionFeesBigIntZod.transform(val => ({
+  base: BigIntToJsonZod.parse(val.base),
+  gasLimit: BigIntToJsonZod.parse(val.gasLimit),
+  gasPrice: BigIntToJsonZod.parse(val.gasPrice),
+  priority: BigIntToJsonZod.parse(val.priority),
+}))
+
+/** TransactionFeesJsonToBigIntZodType type. */
+export type TransactionFeesJsonToBigIntZodType = z.infer<typeof TransactionFeesJsonToBigIntZod>
+/** TransactionFeesBigIntToJsonZodType type. */
+export type TransactionFeesBigIntToJsonZodType = z.infer<typeof TransactionFeesBigIntToJsonZod>
+
+export { BigIntToJsonZod as AttoToJsonZod } from '@xylabs/sdk-js'

package/src/transaction/TransactionGasCosts.ts

@@ -0,0 +1,42 @@
+/** TransactionGasCosts constant. */
+export const TransactionGasCosts = {
+  /**
+   * The cost of storing each character that is added to the chain
+   * This includes the transaction JSON and all the elevated payloads' JSON
+  */
+  characterStorage: 10n,
+
+  /** The cost of static validating every payload that will be included in the chain */
+  payloadValidation: 1000n,
+
+  /** The cost of validating each signature that will be included in the chain */
+  signatureValidation: 1000n,
+
+  /** The cost of validating each hash that will be included in the chain */
+  hashValidation: 100n,
+
+  /** The cost of validating a balance state, triggered by a Transfer payload or gas collection */
+  balanceValidation: 100n,
+} as const
+
+/** Gas Calculation
+ *
+ * 1 Million microXL1 (mXL1) = 1 XL1
+ *
+ * Gas amount is calculated as follows:
+ *
+ * 1. Each byte in the transaction cost 10 gas
+ * 2. Each payload validation in the transaction costs 1000 gas
+ * 3. Each signature verification in the transaction costs 1000 gas
+ * 4. Each hash validation in the transaction costs 100 gas
+ * 5. Each balance validation in the transaction costs 100 gas
+ * 6. Processing/Compute/Storage Cost?
+ * 7. operation Costs?
+ *
+ * The total gas cost is calculated by multiplying the gas amount by the gas price.
+ *
+ * minGasPrice is initially set to 100 mXL1
+ * minBase is initially set to 1000 mXL1
+ * minPriority is always 0 mXL1, but can be set to increase the priority of the transaction
+ *
+ */

package/src/transaction/index.ts

@@ -0,0 +1,3 @@
+export * from './TransactionBoundWitness.ts'
+export * from './TransactionFees.ts'
+export * from './TransactionGasCosts.ts'

package/src/xl1/AttoXL1.ts

@@ -0,0 +1,19 @@
+import {
+  asXL1Factory, isXL1Factory, toXL1Factory,
+} from './isXL1Factory.ts'
+import { xl1MaxValue } from './xl1MaxValue.ts'
+import { XL1Places } from './XL1Units.ts'
+
+/** Maximum value for the AttoXL1 branded type. */
+export const AttoXL1MaxValue = xl1MaxValue(XL1Places.atto)
+/** AttoXL1 type. */
+export type AttoXL1 = bigint & { readonly _tag: 'AttoXL1' }
+/** Type guard that checks if a value is a valid AttoXL1. */
+export const isAttoXL1 = isXL1Factory<AttoXL1>(XL1Places.atto)
+/** Converts a value to AttoXL1, throwing if invalid. */
+export const asAttoXL1 = asXL1Factory<AttoXL1>(XL1Places.atto)
+/** Converts a bigint value to AttoXL1 without validation. */
+export const toAttoXL1 = toXL1Factory<AttoXL1>(XL1Places.atto)
+
+/** Shorthand alias for asAttoXL1. */
+export const AttoXL1 = asAttoXL1

package/src/xl1/FemtoXL1.ts

@@ -0,0 +1,20 @@
+import {
+  asXL1Factory, isXL1Factory, toXL1Factory,
+} from './isXL1Factory.ts'
+import { xl1MaxValue } from './xl1MaxValue.ts'
+import { XL1Places } from './XL1Units.ts'
+
+/** Maximum value for the FemtoXL1 branded type. */
+export const FemtoXL1MaxValue = xl1MaxValue(XL1Places.femto)
+/** FemtoXL1 type. */
+export type FemtoXL1 = bigint & { readonly _tag: 'FemtoXL1' }
+/** Type guard that checks if a value is a valid FemtoXL1. */
+export const isFemtoXL1 = isXL1Factory<FemtoXL1>(XL1Places.femto)
+/** Converts a value to FemtoXL1, throwing if invalid. */
+export const asFemtoXL1 = asXL1Factory<FemtoXL1>(XL1Places.femto)
+
+/** Converts a bigint value to FemtoXL1 without validation. */
+export const toFemtoXL1 = toXL1Factory<FemtoXL1>(XL1Places.femto)
+
+/** Shorthand alias for asFemtoXL1. */
+export const FemtoXL1 = asFemtoXL1

package/src/xl1/MicroXL1.ts

@@ -0,0 +1,20 @@
+import {
+  asXL1Factory, isXL1Factory, toXL1Factory,
+} from './isXL1Factory.ts'
+import { xl1MaxValue } from './xl1MaxValue.ts'
+import { XL1Places } from './XL1Units.ts'
+
+/** Maximum value for the MicroXL1 branded type. */
+export const MicroXL1MaxValue = xl1MaxValue(XL1Places.micro)
+/** MicroXL1 type. */
+export type MicroXL1 = bigint & { readonly _tag: 'MicroXL1' }
+/** Type guard that checks if a value is a valid MicroXL1. */
+export const isMicroXL1 = isXL1Factory<MicroXL1>(XL1Places.micro)
+/** Converts a value to MicroXL1, throwing if invalid. */
+export const asMicroXL1 = asXL1Factory<MicroXL1>(XL1Places.micro)
+
+/** Converts a bigint value to MicroXL1 without validation. */
+export const toMicroXL1 = toXL1Factory<MicroXL1>(XL1Places.micro)
+
+/** Shorthand alias for asMicroXL1. */
+export const MicroXL1 = asMicroXL1

package/src/xl1/MilliXL1.ts

@@ -0,0 +1,20 @@
+import {
+  asXL1Factory, isXL1Factory, toXL1Factory,
+} from './isXL1Factory.ts'
+import { xl1MaxValue } from './xl1MaxValue.ts'
+import { XL1Places } from './XL1Units.ts'
+
+/** Maximum value for the MilliXL1 branded type. */
+export const MilliXL1MaxValue = xl1MaxValue(XL1Places.milli)
+/** MilliXL1 type. */
+export type MilliXL1 = bigint & { readonly _tag: 'MilliXL1' }
+/** Type guard that checks if a value is a valid MilliXL1. */
+export const isMilliXL1 = isXL1Factory<MilliXL1>(XL1Places.milli)
+/** Converts a value to MilliXL1, throwing if invalid. */
+export const asMilliXL1 = asXL1Factory<MilliXL1>(XL1Places.milli)
+
+/** Converts a bigint value to MilliXL1 without validation. */
+export const toMilliXL1 = toXL1Factory<MilliXL1>(XL1Places.milli)
+
+/** Shorthand alias for asMilliXL1. */
+export const MilliXL1 = asMilliXL1

package/src/xl1/NanoXL1.ts

@@ -0,0 +1,20 @@
+import {
+  asXL1Factory, isXL1Factory, toXL1Factory,
+} from './isXL1Factory.ts'
+import { xl1MaxValue } from './xl1MaxValue.ts'
+import { XL1Places } from './XL1Units.ts'
+
+/** Maximum value for the NanoXL1 branded type. */
+export const NanoXL1MaxValue = xl1MaxValue(XL1Places.nano)
+/** NanoXL1 type. */
+export type NanoXL1 = bigint & { readonly _tag: 'NanoXL1' }
+/** Type guard that checks if a value is a valid NanoXL1. */
+export const isNanoXL1 = isXL1Factory<NanoXL1>(XL1Places.nano)
+/** Converts a value to NanoXL1, throwing if invalid. */
+export const asNanoXL1 = asXL1Factory<NanoXL1>(XL1Places.nano)
+
+/** Converts a bigint value to NanoXL1 without validation. */
+export const toNanoXL1 = toXL1Factory<NanoXL1>(XL1Places.nano)
+
+/** Shorthand alias for asNanoXL1. */
+export const NanoXL1 = asNanoXL1

package/src/xl1/PicoXL1.ts

@@ -0,0 +1,20 @@
+import {
+  asXL1Factory, isXL1Factory, toXL1Factory,
+} from './isXL1Factory.ts'
+import { xl1MaxValue } from './xl1MaxValue.ts'
+import { XL1Places } from './XL1Units.ts'
+
+/** PicoXL1MaxValue constant. */
+export const PicoXL1MaxValue = xl1MaxValue(XL1Places.pico)
+/** PicoXL1 type. */
+export type PicoXL1 = bigint & { readonly _tag: 'PicoXL1' }
+/** Type guard that checks if a value is a valid PicoXL1. */
+export const isPicoXL1 = isXL1Factory<PicoXL1>(XL1Places.pico)
+/** Converts a value to PicoXL1, throwing if invalid. */
+export const asPicoXL1 = asXL1Factory<PicoXL1>(XL1Places.pico)
+
+/** toPicoXL1 constant. */
+export const toPicoXL1 = toXL1Factory<PicoXL1>(XL1Places.pico)
+
+/** PicoXL1 constant. */
+export const PicoXL1 = asPicoXL1

package/src/xl1/XL1.ts

@@ -0,0 +1,20 @@
+import {
+  asXL1Factory, isXL1Factory, toXL1Factory,
+} from './isXL1Factory.ts'
+import { xl1MaxValue } from './xl1MaxValue.ts'
+import { XL1Places } from './XL1Units.ts'
+
+/** XL1MaxValue constant. */
+export const XL1MaxValue = xl1MaxValue(XL1Places.xl1)
+/** XL1 type. */
+export type XL1 = bigint & { readonly _tag: 'XL1' }
+/** Type guard that checks if a value is a valid XL1. */
+export const isXL1 = isXL1Factory<XL1>(XL1Places.xl1)
+/** Converts a value to XL1, throwing if invalid. */
+export const asXL1 = asXL1Factory<XL1>(XL1Places.xl1)
+
+/** toXL1 constant. */
+export const toXL1 = toXL1Factory<XL1>(XL1Places.xl1)
+
+/** XL1 constant. */
+export const XL1 = asXL1

package/src/xl1/XL1Units.ts

@@ -0,0 +1,26 @@
+type XL1Units = 'xl1' | 'milli' | 'micro' | 'nano' | 'pico' | 'femto' | 'atto'
+
+/** Decimal place definitions for each XL1 currency unit (atto=18, femto=15, etc.). */
+export const XL1Places: Record<XL1Units, bigint> = {
+  xl1: 18n,
+  milli: 15n,
+  micro: 12n,
+  nano: 9n,
+  pico: 6n,
+  femto: 3n,
+  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

package/src/xl1/index.ts

@@ -0,0 +1,8 @@
+export * from './AttoXL1.ts'
+export * from './FemtoXL1.ts'
+export * from './MicroXL1.ts'
+export * from './MilliXL1.ts'
+export * from './NanoXL1.ts'
+export * from './PicoXL1.ts'
+export * from './XL1.ts'
+export * from './XL1Units.ts'

package/src/xl1/isXL1Factory.ts

@@ -0,0 +1,56 @@
+import { z } from 'zod'
+
+import { xl1MaxValue } from './xl1MaxValue.ts'
+
+/** Type guard that checks if a value is a valid XL1Factory. */
+export const isXL1Factory = <T extends bigint>(places: bigint) => (val: unknown): val is T => {
+  if (typeof val !== 'bigint') return false
+  return val >= 0n && val <= xl1MaxValue(places)
+}
+
+/** Creates a Zod schema factory for XL1 branded bigint types. */
+export const XL1ZodFactory = <T extends bigint>(places: bigint, name: string) => {
+  const is = isXL1Factory<T>(places)
+  const message = `Invalid value for ${name}, must be between 0 and ${xl1MaxValue(places)}`
+  return z.bigint().refine(
+    (x) => {
+      const result = is(x)
+      return result
+    },
+    { message },
+  )
+}
+
+/** Creates a Zod transform factory that converts values between XL1 unit types. */
+export const XL1TransformZodFactory = <T extends bigint>(places: bigint, name: string) => {
+  const is = isXL1Factory<T>(places)
+  const message = `Invalid value for ${name}, must be between 0 and ${xl1MaxValue(places)}`
+  return z.union([z.bigint(), z.number(), z.string(), z.boolean()]).transform(val => BigInt(val) as T).refine(
+    (x) => {
+      const result = is(x)
+      return result
+    },
+    { message },
+  )
+}
+
+/** Converts a value to XL1Factory, throwing if invalid. */
+export const asXL1Factory = <T extends bigint>(places: bigint) => {
+  const zod = XL1ZodFactory<T>(places, 'local')
+  return (val: unknown): T => {
+    const result = zod.safeParse(val)
+    if (result.success) {
+      return result.data as T
+    }
+    throw result.error
+  }
+}
+
+/** Creates a factory function that converts bigint values to a specific XL1 branded type. */
+export const toXL1Factory = <T extends bigint>(places: bigint) => {
+  const zod = XL1TransformZodFactory<T>(places, 'local')
+  return (val: unknown): T | undefined => {
+    const result = zod.safeParse(val)
+    return result.success ? result.data as T : undefined
+  }
+}

package/src/xl1/xl1MaxValue.ts

@@ -0,0 +1,2 @@
+/** Computes the maximum value for an XL1 unit given its decimal places. */
+export const xl1MaxValue = (places: bigint) => 10n ** (32n - places) - 1n