@xyo-network/xl1-protocol-model 1.26.1

package/src/model/Context/BlockContext.ts

@@ -0,0 +1,12 @@
+import type z from 'zod'
+
+import type {
+  BlockContextReadZod, BlockContextWriteZod, BlockContextZod,
+} from './BlockContext.zod.ts'
+
+/** BlockContextRead type. */
+export type BlockContextRead = z.infer<typeof BlockContextReadZod>
+/** BlockContextWrite type. */
+export type BlockContextWrite = z.infer<typeof BlockContextWriteZod>
+/** BlockContext type. */
+export type BlockContext = z.infer<typeof BlockContextZod>

package/src/model/Context/BlockContext.zod.ts

@@ -0,0 +1,20 @@
+import type {
+  Payload,
+  ReadArchivist, WriteArchivist,
+} from '@xyo-network/sdk-js'
+import z from 'zod'
+
+import { CachingContextZod } from './CachingContext.zod.ts'
+
+/** BlockContextReadZod constant. */
+export const BlockContextReadZod = CachingContextZod.extend(
+  { chainMap: z.custom<ReadArchivist<Payload>>(val => val && typeof val === 'object' && ('get' in val)) },
+)
+
+/** BlockContextWriteZod constant. */
+export const BlockContextWriteZod = CachingContextZod.extend(
+  { chainMap: z.custom<WriteArchivist<Payload>>(val => val && typeof val === 'object' && ('get' in val && 'insert' in val)) },
+)
+
+/** BlockContextZod constant. */
+export const BlockContextZod = BlockContextWriteZod

package/src/model/Context/CachingContext.ts

@@ -0,0 +1,6 @@
+import type z from 'zod'
+
+import type { CachingContextZod } from './CachingContext.zod.ts'
+
+/** CachingContext type. */
+export type CachingContext = z.infer<typeof CachingContextZod>

package/src/model/Context/CachingContext.zod.ts

@@ -0,0 +1,4 @@
+import { BaseContextZod, CachesZod } from './BaseContext.zod.ts'
+
+/** CachingContextZod constant. */
+export const CachingContextZod = BaseContextZod.extend({ caches: CachesZod })

package/src/model/Context/ChainContext.ts

@@ -0,0 +1,12 @@
+import type z from 'zod'
+
+import type {
+  ChainContextReadZod, ChainContextWriteZod, ChainContextZod,
+} from './ChainContext.zod.ts'
+
+/** ChainContextRead type. */
+export type ChainContextRead = z.infer<typeof ChainContextReadZod>
+/** ChainContextWrite type. */
+export type ChainContextWrite = z.infer<typeof ChainContextWriteZod>
+/** ChainContext type. */
+export type ChainContext = z.infer<typeof ChainContextZod>

package/src/model/Context/ChainContext.zod.ts

@@ -0,0 +1,17 @@
+import {
+  BlockContextReadZod, BlockContextWriteZod, BlockContextZod,
+} from './BlockContext.zod.ts'
+import { HeadContextBaseZod } from './HeadContext.zod.ts'
+
+/** ChainContextReadZod constant. */
+export const ChainContextReadZod = BlockContextReadZod.safeExtend(HeadContextBaseZod.shape)
+
+/** ChainContextWriteZod constant. */
+export const ChainContextWriteZod = BlockContextWriteZod.safeExtend(
+  HeadContextBaseZod.shape,
+)
+
+/** ChainContextZod constant. */
+export const ChainContextZod = BlockContextZod.safeExtend(
+  HeadContextBaseZod.shape,
+)

package/src/model/Context/HeadContext.ts

@@ -0,0 +1,6 @@
+import type z from 'zod'
+
+import type { HeadContextZod } from './HeadContext.zod.ts'
+
+/** HeadContext type. */
+export type HeadContext = z.infer<typeof HeadContextZod>

package/src/model/Context/HeadContext.zod.ts

@@ -0,0 +1,13 @@
+import { WithHashMetaZod } from '@xyo-network/sdk-js'
+import z from 'zod'
+
+import { BlockBoundWitnessZod } from '../../block/index.ts'
+import { CachingContextZod } from './CachingContext.zod.ts'
+
+/** HeadContextBaseZod constant. */
+export const HeadContextBaseZod = z.object(
+  { head: WithHashMetaZod(BlockBoundWitnessZod) },
+)
+
+/** HeadContextZod constant. */
+export const HeadContextZod = CachingContextZod.safeExtend(HeadContextBaseZod.shape)

package/src/model/Context/index.ts

@@ -0,0 +1,10 @@
+export * from './BaseContext.ts'
+export * from './BaseContext.zod.ts'
+export * from './BlockContext.ts'
+export * from './BlockContext.zod.ts'
+export * from './CachingContext.ts'
+export * from './CachingContext.zod.ts'
+export * from './ChainContext.ts'
+export * from './ChainContext.zod.ts'
+export * from './HeadContext.ts'
+export * from './HeadContext.zod.ts'

package/src/model/GatewayName.ts

@@ -0,0 +1,4 @@
+import type { Brand } from '@xylabs/sdk-js'
+
+/** GatewayName type. */
+export type GatewayName = Brand<string, { __gatewayName: true }>

package/src/model/HydratedTransaction.ts

@@ -0,0 +1,169 @@
+import {
+  zodAsFactory, zodIsFactory, zodToFactory,
+} from '@xylabs/sdk-js'
+import {
+  PayloadZod,
+  PayloadZodLoose, WithHashMetaZod,
+  WithStorageMetaZod,
+} from '@xyo-network/sdk-js'
+import { z } from 'zod'
+
+import {
+  SignedTransactionBoundWitnessZod, TransactionBoundWitnessZod, UnsignedTransactionBoundWitnessZod,
+} from '../transaction/index.ts'
+
+/** HydratedTransactionZod constant. */
+export const HydratedTransactionZod = z.tuple([
+  TransactionBoundWitnessZod,
+  z.array(PayloadZodLoose),
+])
+
+/** Type representing a hydrated Transaction with resolved payloads. */
+export type HydratedTransaction = z.infer<typeof HydratedTransactionZod>
+
+/** Type guard that checks if a value is a valid HydratedTransaction. */
+export const isHydratedTransaction = zodIsFactory(HydratedTransactionZod)
+/** Converts a value to HydratedTransaction, throwing if invalid. */
+export const asHydratedTransaction = zodAsFactory(HydratedTransactionZod, 'asHydratedTransaction')
+/** toHydratedTransaction constant. */
+export const toHydratedTransaction = zodToFactory(HydratedTransactionZod, 'toHydratedTransaction')
+
+/** HydratedTransactionWithHashMetaZod constant. */
+export const HydratedTransactionWithHashMetaZod = z.tuple([
+  WithHashMetaZod(TransactionBoundWitnessZod),
+  z.array(WithHashMetaZod(PayloadZod).loose()),
+])
+
+/** Type representing a hydrated TransactionWithHashMeta with resolved payloads. */
+export type HydratedTransactionWithHashMeta = z.infer<typeof HydratedTransactionWithHashMetaZod>
+
+/** Type guard that checks if a value is a valid HydratedTransactionWithHashMeta. */
+export const isHydratedTransactionWithHashMeta = zodIsFactory(HydratedTransactionWithHashMetaZod)
+/** Converts a value to HydratedTransactionWithHashMeta, throwing if invalid. */
+export const asHydratedTransactionWithHashMeta = zodAsFactory(HydratedTransactionWithHashMetaZod, 'asHydratedTransactionWithHashMeta')
+/** toHydratedTransactionWithHashMeta constant. */
+export const toHydratedTransactionWithHashMeta = zodToFactory(HydratedTransactionWithHashMetaZod, 'toHydratedTransactionWithHashMeta')
+
+/** HydratedTransactionWithStorageMetaZod constant. */
+export const HydratedTransactionWithStorageMetaZod = z.tuple([
+  WithStorageMetaZod(TransactionBoundWitnessZod),
+  z.array(WithStorageMetaZod(PayloadZod).loose()),
+])
+
+/** Type representing a hydrated TransactionWithStorageMeta with resolved payloads. */
+export type HydratedTransactionWithStorageMeta = z.infer<typeof HydratedTransactionWithStorageMetaZod>
+
+/** Type guard that checks if a value is a valid HydratedTransactionWithStorageMeta. */
+export const isHydratedTransactionWithStorageMeta = zodIsFactory(HydratedTransactionWithStorageMetaZod)
+/** Converts a value to HydratedTransactionWithStorageMeta, throwing if invalid. */
+export const asHydratedTransactionWithStorageMeta = zodAsFactory(HydratedTransactionWithStorageMetaZod, 'asHydratedTransactionWithStorageMeta')
+/** toHydratedTransactionWithStorageMeta constant. */
+export const toHydratedTransactionWithStorageMeta = zodToFactory(HydratedTransactionWithStorageMetaZod, 'toHydratedTransactionWithStorageMeta')
+
+/** UnsignedHydratedTransactionZod constant. */
+export const UnsignedHydratedTransactionZod = z.tuple([
+  UnsignedTransactionBoundWitnessZod,
+  z.array(PayloadZodLoose),
+])
+
+/** Type representing a hydrated UnsignedTransaction with resolved payloads. */
+export type UnsignedHydratedTransaction = z.infer<typeof UnsignedHydratedTransactionZod>
+
+/** Type guard that checks if a value is a valid UnsignedHydratedTransaction. */
+export const isUnsignedHydratedTransaction = zodIsFactory(UnsignedHydratedTransactionZod)
+/** Converts a value to UnsignedHydratedTransaction, throwing if invalid. */
+export const asUnsignedHydratedTransaction = zodAsFactory(UnsignedHydratedTransactionZod, 'asUnsignedHydratedTransaction')
+/** toUnsignedHydratedTransaction constant. */
+export const toUnsignedHydratedTransaction = zodToFactory(UnsignedHydratedTransactionZod, 'toUnsignedHydratedTransaction')
+
+/** UnsignedHydratedTransactionWithHashMetaZod constant. */
+export const UnsignedHydratedTransactionWithHashMetaZod = z.tuple([
+  WithHashMetaZod(UnsignedTransactionBoundWitnessZod),
+  z.array(WithHashMetaZod(PayloadZod).loose()),
+])
+
+/** Type representing a hydrated UnsignedTransactionWithHashMeta with resolved payloads. */
+export type UnsignedHydratedTransactionWithHashMeta = z.infer<typeof UnsignedHydratedTransactionWithHashMetaZod>
+
+/** Type guard that checks if a value is a valid UnsignedHydratedTransactionWithHashMeta. */
+export const isUnsignedHydratedTransactionWithHashMeta = zodIsFactory(UnsignedHydratedTransactionWithHashMetaZod)
+/** Converts a value to UnsignedHydratedTransactionWithHashMeta, throwing if invalid. */
+export const asUnsignedHydratedTransactionWithHashMeta = zodAsFactory(UnsignedHydratedTransactionWithHashMetaZod, 'asUnsignedHydratedTransactionWithHashMeta')
+/** toUnsignedHydratedTransactionWithHashMeta constant. */
+export const toUnsignedHydratedTransactionWithHashMeta = zodToFactory(UnsignedHydratedTransactionWithHashMetaZod, 'toUnsignedHydratedTransactionWithHashMeta')
+
+/** UnsignedHydratedTransactionWithStorageMetaZod constant. */
+export const UnsignedHydratedTransactionWithStorageMetaZod = z.tuple([
+  WithStorageMetaZod(UnsignedTransactionBoundWitnessZod),
+  z.array(WithStorageMetaZod(PayloadZod).loose()),
+])
+
+/** Type representing a hydrated UnsignedTransactionWithStorageMeta with resolved payloads. */
+export type UnsignedHydratedTransactionWithStorageMeta = z.infer<typeof UnsignedHydratedTransactionWithStorageMetaZod>
+
+/** Type guard that checks if a value is a valid UnsignedHydratedTransactionWithStorageMeta. */
+export const isUnsignedHydratedTransactionWithStorageMeta = zodIsFactory(UnsignedHydratedTransactionWithStorageMetaZod)
+/** Converts a value to UnsignedHydratedTransactionWithStorageMeta, throwing if invalid. */
+export const asUnsignedHydratedTransactionWithStorageMeta = zodAsFactory(
+  UnsignedHydratedTransactionWithStorageMetaZod,
+  'asUnsignedHydratedTransactionWithStorageMeta',
+)
+/** toUnsignedHydratedTransactionWithStorageMeta constant. */
+export const toUnsignedHydratedTransactionWithStorageMeta = zodToFactory(
+  UnsignedHydratedTransactionWithStorageMetaZod,
+  'toUnsignedHydratedTransactionWithStorageMeta',
+)
+
+/** SignedHydratedTransactionZod constant. */
+export const SignedHydratedTransactionZod = z.tuple([
+  SignedTransactionBoundWitnessZod,
+  z.array(PayloadZodLoose),
+])
+
+/** Type representing a hydrated SignedTransaction with resolved payloads. */
+export type SignedHydratedTransaction = z.infer<typeof SignedHydratedTransactionZod>
+
+/** Type guard that checks if a value is a valid SignedHydratedTransaction. */
+export const isSignedHydratedTransaction = zodIsFactory(SignedHydratedTransactionZod)
+/** Converts a value to SignedHydratedTransaction, throwing if invalid. */
+export const asSignedHydratedTransaction = zodAsFactory(SignedHydratedTransactionZod, 'asSignedHydratedTransaction')
+/** toSignedHydratedTransaction constant. */
+export const toSignedHydratedTransaction = zodToFactory(SignedHydratedTransactionZod, 'toSignedHydratedTransaction')
+
+/** SignedHydratedTransactionWithHashMetaZod constant. */
+export const SignedHydratedTransactionWithHashMetaZod = z.tuple([
+  WithHashMetaZod(SignedTransactionBoundWitnessZod),
+  z.array(WithHashMetaZod(PayloadZod).loose()),
+])
+
+/** Type representing a hydrated SignedTransactionWithHashMeta with resolved payloads. */
+export type SignedHydratedTransactionWithHashMeta = z.infer<typeof SignedHydratedTransactionWithHashMetaZod>
+
+/** Type guard that checks if a value is a valid SignedHydratedTransactionWithHashMeta. */
+export const isSignedHydratedTransactionWithHashMeta = zodIsFactory(SignedHydratedTransactionWithHashMetaZod)
+/** Converts a value to SignedHydratedTransactionWithHashMeta, throwing if invalid. */
+export const asSignedHydratedTransactionWithHashMeta = zodAsFactory(SignedHydratedTransactionWithHashMetaZod, 'asSignedHydratedTransactionWithHashMeta')
+/** toSignedHydratedTransactionWithHashMeta constant. */
+export const toSignedHydratedTransactionWithHashMeta = zodToFactory(SignedHydratedTransactionWithHashMetaZod, 'toSignedHydratedTransactionWithHashMeta')
+
+/** SignedHydratedTransactionWithStorageMetaZod constant. */
+export const SignedHydratedTransactionWithStorageMetaZod = z.tuple([
+  WithStorageMetaZod(SignedTransactionBoundWitnessZod),
+  z.array(WithStorageMetaZod(PayloadZod).loose()),
+])
+
+/** Type representing a hydrated SignedTransactionWithStorageMeta with resolved payloads. */
+export type SignedHydratedTransactionWithStorageMeta = z.infer<typeof SignedHydratedTransactionWithStorageMetaZod>
+
+/** Type guard that checks if a value is a valid SignedHydratedTransactionWithStorageMeta. */
+export const isSignedHydratedTransactionWithStorageMeta = zodIsFactory(SignedHydratedTransactionWithStorageMetaZod)
+/** Converts a value to SignedHydratedTransactionWithStorageMeta, throwing if invalid. */
+export const asSignedHydratedTransactionWithStorageMeta = zodAsFactory(
+  SignedHydratedTransactionWithStorageMetaZod,
+  'asSignedHydratedTransactionWithStorageMeta',
+)
+/** toSignedHydratedTransactionWithStorageMeta constant. */
+export const toSignedHydratedTransactionWithStorageMeta = zodToFactory(
+  SignedHydratedTransactionWithStorageMetaZod,
+  'toSignedHydratedTransactionWithStorageMeta',
+)

package/src/model/OpCodes.ts

@@ -0,0 +1,2 @@
+/** ELEVATE_OPCODE constant. */
+export const ELEVATE_OPCODE = 'elevate'

package/src/model/PayloadMap.ts

@@ -0,0 +1,13 @@
+import type { Hash } from '@xylabs/sdk-js'
+import type { Payload } from '@xyo-network/sdk-js'
+
+import type {
+  MapType, MapTypeRead, MapTypeWrite,
+} from '../map/index.ts'
+
+/** PayloadMapWrite type. */
+export type PayloadMapWrite<T extends Payload = Payload> = MapTypeWrite<Hash, T>
+/** PayloadMapRead type. */
+export type PayloadMapRead<T extends Payload = Payload> = MapTypeRead<Hash, T>
+/** PayloadMap type. */
+export type PayloadMap<T extends Payload = Payload> = MapType<Hash, T>

package/src/model/Permission.ts

@@ -0,0 +1,29 @@
+import { z } from 'zod'
+
+/** CaveatTypesZod constant. */
+export const CaveatTypesZod = z.enum(['chain', 'expiration', 'filteredResponse', 'rateLimit', 'restrictReturnedAccounts'])
+
+/** CaveatsZod constant. */
+export const CaveatsZod = z.object({
+  type: CaveatTypesZod,
+  value: z.json(),
+})
+
+/** PermissionZod constant. */
+export const PermissionZod = z.object({
+  parentCapability: z.string(),
+  caveats: CaveatsZod.array().optional(),
+  invoker: z.string(),
+})
+
+/** InvokerPermissionZod constant. */
+export const InvokerPermissionZod = PermissionZod.safeExtend({ date: z.number().optional() })
+
+/** PermissionRequestZod constant. */
+export const PermissionRequestZod = z.record(z.string(), z.record(z.string(), z.any()))
+
+/** RequestedPermissionZod constant. */
+export const RequestedPermissionZod = z.object({
+  parentCapability: z.string(),
+  date: z.number().optional(),
+})

package/src/model/Position.ts

@@ -0,0 +1,21 @@
+import type { Address } from '@xylabs/sdk-js'
+
+import type { PositionId } from './PositionId.ts'
+
+/** Position type. */
+export type Position = {
+  // the block number when the stake was added
+  addBlock: number
+  // the amount that is staked
+  amount: bigint
+  // the unique id for the stake item
+  id: PositionId
+  // the block number when the stake was removed (set to 0 if not removed)
+  removeBlock: number
+  // the address that is being staked
+  staked: Address
+  // the address that owns the stake
+  staker: Address
+  // the block number when the stake was withdrawn (set to 0 if not withdrawn)
+  withdrawBlock: number
+}

package/src/model/PositionId.ts

@@ -0,0 +1,4 @@
+import type { Brand } from '@xylabs/sdk-js'
+
+/** PositionId type. */
+export type PositionId = Brand<number, { readonly __positionId: true }>

package/src/model/RangeMultipliers.ts

@@ -0,0 +1,13 @@
+import type {
+  BlockRangeKey, EthBlockRangeKey, XL1BlockRangeKey,
+} from './BlockRange/index.ts'
+
+/** BigFraction type. */
+export type BigFraction = [bigint, bigint] // numerator, denominator
+
+/** RangeMultipliers type. */
+export type RangeMultipliers = Record<BlockRangeKey, BigFraction>
+/** EthRangeMultipliers type. */
+export type EthRangeMultipliers = Record<EthBlockRangeKey, BigFraction>
+/** XL1RangeMultipliers type. */
+export type XL1RangeMultipliers = Record<XL1BlockRangeKey, BigFraction>

package/src/model/RewardShare.ts

@@ -0,0 +1,2 @@
+/** RewardShare type. */
+export type RewardShare = [bigint, bigint] // [share, total]

package/src/model/RewardsRangeOptions.ts

@@ -0,0 +1,13 @@
+import { AddressZod } from '@xylabs/sdk-js'
+import { z } from 'zod'
+
+import { StepIdentityZod } from '../Step/index.ts'
+import { BlockRangeZod } from './BlockRange/index.ts'
+
+/** RewardsRangeOptionsZod constant. */
+export const RewardsRangeOptionsZod = z.object({
+  positions: z.array(z.number()).optional(),
+  range: BlockRangeZod.optional(),
+  steps: z.array(StepIdentityZod).optional(),
+  stakers: z.array(AddressZod).optional(),
+})

package/src/model/Sequence.ts

@@ -0,0 +1,21 @@
+import { HexRegExMinMax, toHex } from '@xylabs/sdk-js'
+import type { LocalSequence, QualifiedSequence } from '@xyo-network/sdk-js'
+import { SequenceConstants } from '@xyo-network/sdk-js'
+import { z } from 'zod'
+
+const LocalSequenceRegex = new RegExp(HexRegExMinMax(SequenceConstants.localSequenceBytes, SequenceConstants.localSequenceBytes))
+/** LocalSequenceToStringZod constant. */
+export const LocalSequenceToStringZod = z.string().regex(LocalSequenceRegex)
+/** LocalSequenceFromStringZod constant. */
+export const LocalSequenceFromStringZod = z.string().regex(LocalSequenceRegex).transform<LocalSequence>(v => toHex(v) as LocalSequence)
+
+const QualifiedSequenceRegex = new RegExp(HexRegExMinMax(SequenceConstants.qualifiedSequenceBytes, SequenceConstants.qualifiedSequenceBytes))
+/** QualifiedSequenceToStringZod constant. */
+export const QualifiedSequenceToStringZod = z.string().regex(QualifiedSequenceRegex)
+/** QualifiedSequenceFromStringZod constant. */
+export const QualifiedSequenceFromStringZod = z.string().regex(QualifiedSequenceRegex).transform<QualifiedSequence>(v => toHex(v) as QualifiedSequence)
+
+/** SequenceToStringZod constant. */
+export const SequenceToStringZod = z.union([LocalSequenceToStringZod, QualifiedSequenceToStringZod])
+/** SequenceFromStringZod constant. */
+export const SequenceFromStringZod = z.union([LocalSequenceFromStringZod, QualifiedSequenceFromStringZod])

package/src/model/Stake.ts

@@ -0,0 +1,47 @@
+import { AddressZod, HexZod } from '@xylabs/sdk-js'
+import { z } from 'zod'
+
+import {
+  AttoToJsonZod, AttoZod, JsonToAttoZod,
+} from '../transaction/index.ts'
+import type { PositionId } from './PositionId.ts'
+
+/** StakeZod constant. */
+export const StakeZod = z.object({
+  amount: AttoZod,
+  // the block number when the stake was added
+  addBlock: z.number(),
+  // the unique id for the stake item
+  id: z.number(),
+  // the block number when the stake was removed (set to 0 if not removed)
+  removeBlock: z.number(),
+  // the address that is being staked
+  staked: AddressZod,
+  // the address that owns the stake
+  staker: AddressZod,
+  // the block number when the stake was withdrawn (set to 0 if not withdrawn)
+  withdrawBlock: z.number(),
+})
+
+/** StakeToJsonZod constant. */
+export const StakeToJsonZod = StakeZod.transform(val => ({
+  addBlock: val.addBlock,
+  amount: AttoToJsonZod.parse(val.amount),
+  id: val.id,
+  removeBlock: val.removeBlock,
+  staked: AddressZod.parse(val.staked),
+  staker: AddressZod.parse(val.staker),
+  withdrawBlock: val.withdrawBlock,
+}))
+
+// we intentionally use extend and not safeExtend here to ensure all fields are present
+/** JsonToStakeZod constant. */
+export const JsonToStakeZod = StakeZod.extend({ amount: HexZod }).transform(val => ({
+  addBlock: val.addBlock,
+  amount: JsonToAttoZod.parse(val.amount),
+  id: val.id as PositionId,
+  removeBlock: val.removeBlock,
+  staked: val.staked,
+  staker: val.staker,
+  withdrawBlock: val.withdrawBlock,
+}))

package/src/model/StakeShare.ts

@@ -0,0 +1,2 @@
+/** StakeShare type. */
+export type StakeShare = [bigint, bigint] // [share, total]

package/src/model/TimeDomain.ts

@@ -0,0 +1,8 @@
+import { z } from 'zod'
+
+/** TimeDomainZod constant. */
+export const TimeDomainZod = z.union([
+  z.literal('xl1'),
+  z.literal('epoch'),
+  z.literal('ethereum'),
+])

package/src/model/TransferPair.ts

@@ -0,0 +1,7 @@
+import { AddressZod } from '@xylabs/sdk-js'
+import { z } from 'zod'
+
+/** TransferPairZod constant. */
+export const TransferPairZod = z.tuple([
+  AddressZod, AddressZod,
+])

package/src/model/addresses.ts

@@ -0,0 +1,36 @@
+import type { Address, EthAddress } from '@xylabs/sdk-js'
+
+/**
+ * The Zero Address is used as a marker address for various protocol operations.
+ */
+export const XYO_ZERO_ADDRESS = '0000000000000000000000000000000000000000' as const as Address
+
+/**
+ * The Bridge Address is used as a marker address for bridge transactions.
+ */
+export const XYO_BRIDGE_ADDRESS = '3012193230121932301219323012193230121932' as const as Address
+
+/**
+ * The Network Staking Address is used as a marker address for staking the network.
+ */
+export const XYO_NETWORK_STAKING_ADDRESS = '1969196919691969196919691969196919691969' as const as Address
+
+/**
+ * The Step Reward Address is used as a marker address for step rewards.
+ */
+export const XYO_STEP_REWARD_ADDRESS = '1216197612161976121619761216197612161976' as const as Address
+
+/** XL1_ETH_MAIN_ERC20_CONTRACT_ADDRESS constant. */
+export const XL1_ETH_MAIN_ERC20_CONTRACT_ADDRESS = '0xf72aE3E0DA743033AbD7A407557D684c1aE66aed' as const as EthAddress
+
+/** XL1_ETH_MAIN_SUB_GOVERNOR_ADDRESS constant. */
+export const XL1_ETH_MAIN_SUB_GOVERNOR_ADDRESS = '0xbA296Bc5D0949C0484f08c56c30FB95CC4675A29' as const as EthAddress
+
+/** XL1_ETH_MAIN_REWARDS_ADDRESS constant. */
+export const XL1_ETH_MAIN_REWARDS_ADDRESS = '0x1a546e091FB4EFb274DC584334a28b8754c4ece7' as const as EthAddress
+
+/** XL1_ETH_MAIN_STAKED_XYO_CHAIN_ADDRESS constant. */
+export const XL1_ETH_MAIN_STAKED_XYO_CHAIN_ADDRESS = '0x319e667cED10452A117472811130444dED357F26' as const as EthAddress
+
+/** XL1_ETH_MAIN_GOVERNANCE_ADDRESS constant. */
+export const XL1_ETH_MAIN_GOVERNANCE_ADDRESS = '0x7595710956d6B14b4f2F51a8dF41379eEeC9074E' as const as EthAddress

package/src/model/defaultRewardRatio.ts

@@ -0,0 +1,3 @@
+// the percent of the block rewards the producer gets
+/** defaultRewardRatio value. */
+export const defaultRewardRatio = 0.05 as const // 5.0% goes to block producer

package/src/model/defaultTransactionFees.ts

@@ -0,0 +1,11 @@
+import type { TransactionFeesBigInt } from '../transaction/index.ts'
+import { AttoXL1, AttoXL1ConvertFactor } from '../xl1/index.ts'
+import { minTransactionFees } from './minTransactionFees.ts'
+
+/** defaultTransactionFees value. */
+export const defaultTransactionFees: TransactionFeesBigInt = {
+  base: minTransactionFees.base,
+  gasPrice: AttoXL1(10n * AttoXL1ConvertFactor.nano),
+  gasLimit: AttoXL1(1_000_000n * AttoXL1ConvertFactor.nano),
+  priority: minTransactionFees.priority,
+} as const

package/src/model/index.ts

@@ -0,0 +1,27 @@
+export * from './AccountBalance.ts'
+export * from './addresses.ts'
+export * from './ArrayBuffer.ts'
+export * from './BlockRange/index.ts'
+export * from './BlockRate.ts'
+export * from './ChainQualification.ts'
+export * from './Context/index.ts'
+export * from './defaultRewardRatio.ts'
+export * from './defaultTransactionFees.ts'
+export * from './GatewayName.ts'
+export * from './HydratedTransaction.ts'
+export * from './minTransactionFees.ts'
+export * from './OpCodes.ts'
+export * from './PayloadMap.ts'
+export * from './Permission.ts'
+export * from './Position.ts'
+export * from './PositionId.ts'
+export * from './PositionId.ts'
+export * from './RangeMultipliers.ts'
+export * from './rewards.ts'
+export * from './RewardShare.ts'
+export * from './RewardsRangeOptions.ts'
+export * from './Sequence.ts'
+export * from './Stake.ts'
+export * from './TimeDomain.ts'
+export * from './TransferPair.ts'
+export * from './version.ts'

package/src/model/minTransactionFees.ts

@@ -0,0 +1,10 @@
+import type { TransactionFeesBigInt } from '../transaction/index.ts'
+import { AttoXL1, AttoXL1ConvertFactor } from '../xl1/index.ts'
+
+/** minTransactionFees value. */
+export const minTransactionFees: TransactionFeesBigInt = {
+  base: AttoXL1(1000n * AttoXL1ConvertFactor.nano),
+  gasPrice: AttoXL1(10n * AttoXL1ConvertFactor.nano),
+  gasLimit: AttoXL1(1_000_000n * AttoXL1ConvertFactor.nano),
+  priority: AttoXL1(0n * AttoXL1ConvertFactor.nano),
+} as const

package/src/model/rewards.ts

@@ -0,0 +1,18 @@
+import { toFixedPoint } from '@xylabs/sdk-js'
+
+import { asAttoXL1 } from '../xl1/index.ts'
+
+/** XL1_REWARDS_PLACES constant. */
+export const XL1_REWARDS_PLACES = 18 as const
+/** XL1_REWARDS_STARTING_REWARD constant. */
+export const XL1_REWARDS_STARTING_REWARD = asAttoXL1(toFixedPoint(500n, XL1_REWARDS_PLACES))
+/** XL1_REWARDS_BLOCKS_PER_STEP constant. */
+export const XL1_REWARDS_BLOCKS_PER_STEP = 1_000_000
+/** XL1_REWARDS_STEP_FACTOR_NUMERATOR constant. */
+export const XL1_REWARDS_STEP_FACTOR_NUMERATOR = 95n
+/** XL1_REWARDS_STEP_FACTOR_DENOMINATOR constant. */
+export const XL1_REWARDS_STEP_FACTOR_DENOMINATOR = 100n
+/** XL1_REWARDS_MIN_BLOCK_REWARD constant. */
+export const XL1_REWARDS_MIN_BLOCK_REWARD = asAttoXL1(toFixedPoint(10n, XL1_REWARDS_PLACES))
+/** XL1_REWARDS_CREATOR_REWARD constant. */
+export const XL1_REWARDS_CREATOR_REWARD = asAttoXL1(toFixedPoint(20_000_000_000n, XL1_REWARDS_PLACES))

package/src/model/spec/fixtures/index.ts

@@ -0,0 +1,2 @@
+export * from './signedHydratedTransaction.ts'
+export * from './unsignedHydratedTransaction.ts'