@xyo-network/xl1-protocol-sdk 1.11.0 → 1.12.0

package/src/config/Config.ts

@@ -1,33 +1,27 @@
-import type { LogLevelKey } from '@xylabs/logger'
-import { LogLevel } from '@xylabs/logger'
 import z from 'zod'
 
-import { ApiConfigSchema } from './Api.ts'
-import { AppConfigSchema } from './App.ts'
-import { ChainConfigSchema } from './Chain.ts'
-import { EvmConfigSchema } from './Evm.ts'
-import { ProducerConfigSchema } from './Producer.ts'
-import { StorageConfigSchema } from './storage/index.ts'
-import { TelemetryConfigSchema } from './Telemetry.ts'
+import { ApiConfigZod } from './Api.ts'
+import { AppConfigZod } from './App.ts'
+import { ChainConfigZod } from './Chain.ts'
+import { EvmConfigZod } from './Evm.ts'
+import { LogConfigZod } from './Log.ts'
+import { ProducerConfigZod } from './Producer.ts'
+import { StorageConfigZod } from './storage/index.ts'
+import { TelemetryConfigZod } from './Telemetry.ts'
 
-const LogLevels = Object.keys(LogLevel) as [LogLevelKey, ...LogLevelKey[]]
+export const Xl1CommonConfigSchema = z.object({ ...LogConfigZod.shape }).describe('XL1 common configuration options')
 
-export const Xl1CommonConfigSchema = z.object({
-  silent: z.boolean().default(false).describe('Whether to run in silent mode'),
-  logLevel: z.enum(LogLevels).default('info').describe('Desired process verbosity'),
-}).describe('XL1 common configuration options')
-
-export const ConfigSchema = z.object({
+export const ConfigZod = z.object({
   ...Xl1CommonConfigSchema.shape,
-  api: ApiConfigSchema.default(ApiConfigSchema.parse({})).describe('Configuration for the API node'),
-  app: AppConfigSchema.default(AppConfigSchema.parse({})).describe('Configuration for the application'),
-  chain: ChainConfigSchema.default(ChainConfigSchema.parse({})).describe('Configuration for the chain'),
-  evm: EvmConfigSchema.default(EvmConfigSchema.parse({})).describe('Configuration for EVM-backed services'),
-  producer: ProducerConfigSchema.default(ProducerConfigSchema.parse({})).describe('Configuration for the producer'),
-  storage: StorageConfigSchema.default(StorageConfigSchema.parse({})).describe('Configuration for the storage'),
-  telemetry: TelemetryConfigSchema.default(TelemetryConfigSchema.parse({})).describe('Configuration for telemetry'),
+  api: ApiConfigZod.default(ApiConfigZod.parse({})).describe('Configuration for the API node'),
+  app: AppConfigZod.default(AppConfigZod.parse({})).describe('Configuration for the application'),
+  chain: ChainConfigZod.default(ChainConfigZod.parse({})).describe('Configuration for the chain'),
+  evm: EvmConfigZod.default(EvmConfigZod.parse({})).describe('Configuration for EVM-backed services'),
+  producer: ProducerConfigZod.default(ProducerConfigZod.parse({})).describe('Configuration for the producer'),
+  storage: StorageConfigZod.default(StorageConfigZod.parse({})).describe('Configuration for the storage'),
+  telemetry: TelemetryConfigZod.default(TelemetryConfigZod.parse({})).describe('Configuration for telemetry'),
 })
 
-export type Config = z.infer<typeof ConfigSchema>
+export type Config = z.infer<typeof ConfigZod>
 
-export const getDefaultConfig = (): Config => ConfigSchema.parse({})
+export const getDefaultConfig = (): Config => ConfigZod.parse({})

package/src/config/Evm.ts

@@ -1,17 +1,34 @@
-import z from 'zod'
+import z, { globalRegistry } from 'zod'
 
-export const EvmJsonRpcConfigSchema = z.object({
-  //
-  url: z.string().optional().describe('JSON-RPC URL'),
+export const EvmInfuraConfigZod = z.object({
+  projectId: z.string().optional().register(globalRegistry, {
+    description: 'Infura project ID',
+    title: 'evm.infura.projectId',
+    type: 'string',
+  }),
+  projectSecret: z.string().optional().register(globalRegistry, {
+    description: 'Infura project secret',
+    title: 'evm.infura.projectSecret',
+    type: 'string',
+  }),
 })
-export const EvmInfuraConfigSchema = z.object({
-  projectId: z.string().optional().describe('Infura project ID'),
-  projectSecret: z.string().optional().describe('Infura project secret'),
+
+export const EvmJsonRpcConfigZod = z.object({
+  url: z.url().optional().register(globalRegistry, {
+    description: 'JSON-RPC URL',
+    title: 'evm.jsonRpc.url',
+    type: 'string',
+  }),
 })
-export const EvmConfigSchema = z.object({
-  chainId: z.string().optional().describe('EVM chain ID'),
-  infura: EvmInfuraConfigSchema.optional().describe('Infura Provider configuration'),
-  jsonRpc: EvmJsonRpcConfigSchema.optional().describe('JSON-RPC Provider configuration'),
+
+export const EvmConfigZod = z.object({
+  chainId: z.string().optional().register(globalRegistry, {
+    description: 'EVM chain ID',
+    title: 'evm.chainId',
+    type: 'string',
+  }),
+  infura: EvmInfuraConfigZod.optional().describe('Infura Provider configuration'),
+  jsonRpc: EvmJsonRpcConfigZod.optional().describe('JSON-RPC Provider configuration'),
 })
 
-export type EvmConfig = z.infer<typeof EvmConfigSchema>
+export type EvmConfig = z.infer<typeof EvmConfigZod>

package/src/config/Log.ts

@@ -1,6 +1,22 @@
 import type { LogLevelKey } from '@xylabs/logger'
 import { LogLevel } from '@xylabs/logger'
-import z from 'zod'
+import z, { globalRegistry } from 'zod'
 const LogLevels = Object.keys(LogLevel) as [LogLevelKey, ...LogLevelKey[]]
 
-export const LogConfigSchema = z.object({ level: z.enum(LogLevels).default('info').describe('Desired process verbosity') })
+export const LogConfigZod = z.object({
+  logLevel: z.enum(LogLevels).default('info').register(globalRegistry, {
+    choices: LogLevels,
+    default: 'info',
+    description: 'Desired process verbosity',
+    title: 'logLevel',
+    type: 'string',
+  }),
+  silent: z.boolean().default(false).register(globalRegistry, {
+    default: false,
+    description: 'Whether to run in silent mode',
+    title: 'silent',
+    type: 'boolean',
+  }),
+})
+
+export type LogConfig = z.infer<typeof LogConfigZod>

package/src/config/Producer.ts

@@ -1,16 +1,43 @@
-import z from 'zod'
+import z, { globalRegistry } from 'zod'
 
-import { MnemonicStringSchema } from '../validation/index.ts'
+import { MnemonicStringZod } from '../validation/index.ts'
 
-export const ProducerConfigSchema = z.object({
+export const ProducerConfigZod = z.object({
+  disableIntentRedeclaration: z.boolean().optional().register(globalRegistry, {
+    description: 'Should the producer skip redeclaring their intent to continue producing blocks',
+    title: 'producer.disableIntentRedeclaration',
+    type: 'boolean',
+  }),
   // TODO: Port schema
-  healthCheckPort: z.coerce.number().optional().describe('Port for the Producer health checks'),
+  healthCheckPort: z.coerce.number().optional().register(globalRegistry, {
+    description: 'Port for the Producer health checks',
+    title: 'producer.healthCheckPort',
+    type: 'number',
+  }),
   // TODO: BigInt schema
-  minStake: z.coerce.number().default(1).describe('Minimum stake required to be a Producer'),
-  mnemonic: MnemonicStringSchema.optional().describe('Mnemonic for the Producer wallet'),
+  minStake: z.coerce.number().default(1).register(globalRegistry, {
+    description: 'Minimum stake required to be a Producer',
+    title: 'producer.minStake',
+    type: 'number',
+  }),
+  mnemonic: MnemonicStringZod.optional().register(globalRegistry, {
+    description: 'Mnemonic for the Producer wallet',
+    title: 'producer.mnemonic',
+    type: 'string',
+  }),
   // TODO: Port schema
-  port: z.coerce.number().default(8081).describe('Port for the Producer'),
-  disableIntentRedeclaration: z.boolean().optional().describe('Should the producer skip redeclaring their intent to continue producing blocks'),
+  port: z.coerce.number().default(8081).register(globalRegistry, {
+    default: 8081,
+    description: 'Port for the Producer',
+    title: 'producer.port',
+    type: 'number',
+  }),
   // TODO: Address schema
-  rewardAddress: z.string().optional().describe('Address to receive block rewards'),
+  rewardAddress: z.string().optional().register(globalRegistry, {
+    description: 'Address to receive block rewards',
+    title: 'producer.rewardAddress',
+    type: 'string',
+  }),
 })
+
+export type ProducerConfig = z.infer<typeof ProducerConfigZod>

package/src/config/Telemetry.ts

@@ -1,13 +1,17 @@
-import z from 'zod'
+import z, { globalRegistry } from 'zod'
 
-export const OpenTelemetryConfigSchema = z.object({
+export const OpenTelemetryConfigZod = z.object({
   // OpenTelemetry options
-  otlpEndpoint: z.string().optional().describe('OTLP endpoint for exporting telemetry data'),
+  otlpEndpoint: z.url().optional().register(globalRegistry, {
+    description: 'OTLP endpoint for exporting telemetry data',
+    title: 'telemetry.otel.otlpEndpoint',
+    type: 'string',
+  }),
 })
 
-export const TelemetryConfigSchema = z.object({
+export const TelemetryConfigZod = z.object({
   // OpenTelemetry configuration
-  otel: OpenTelemetryConfigSchema.optional().describe('OpenTelemetry configuration'),
+  otel: OpenTelemetryConfigZod.optional().describe('OpenTelemetry configuration'),
 }).describe('Telemetry configuration options')
 
-export type TelemetryConfig = z.infer<typeof TelemetryConfigSchema>
+export type TelemetryConfig = z.infer<typeof TelemetryConfigZod>

package/src/config/UsageMeta.ts

@@ -0,0 +1,41 @@
+import z from 'zod'
+
+const DescriptionSchema = z.string()
+const TitleSchema = z.string()
+
+export const JSONSchemaMetaSchema = z
+  .object({
+    id: z.string().optional(),
+    title: TitleSchema.optional(),
+    description: DescriptionSchema.optional(),
+    deprecated: z.boolean().optional(),
+  })
+  .catchall(z.unknown()) // allow arbitrary extra keys
+
+export const GlobalMetaSchema = JSONSchemaMetaSchema.extend({})
+
+const ChoicesSchema = z
+  .array(z.union([z.string(), z.number(), z.literal(true), z.undefined()]))
+  .readonly()
+
+export const UsageMetaSchema = GlobalMetaSchema.extend({
+  choices: ChoicesSchema.optional(),
+  default: z.unknown().optional(),
+  description: DescriptionSchema,
+  group: z.string().optional(),
+  hidden: z.boolean().optional(),
+  title: TitleSchema,
+  type: z.union([
+    z.literal('array'),
+    z.literal('count'),
+    z.literal('boolean'),
+    z.literal('number'),
+    z.literal('string'),
+  ]),
+})
+
+export type UsageMeta = z.infer<typeof UsageMetaSchema>
+
+export function isUsageMeta(v: unknown): v is UsageMeta {
+  return UsageMetaSchema.safeParse(v).success
+}

package/src/config/index.ts

@@ -1,2 +1,3 @@
 export * from './Config.ts'
 export { hasMongoConfig } from './storage/index.ts'
+export * from './UsageMeta.ts'

package/src/config/storage/Storage.ts

@@ -1,10 +1,14 @@
-import z from 'zod'
+import z, { globalRegistry } from 'zod'
 
-import { MongoConfigSchema } from './driver/index.ts'
+import { MongoConfigZod } from './driver/index.ts'
 
-export const StorageConfigSchema = z.object({
-  mongo: MongoConfigSchema.optional().describe('Configuration for the MongoDBstorage driver'),
-  root: z.string().optional().describe('Root directory for local storage'),
+export const StorageConfigZod = z.object({
+  mongo: MongoConfigZod.optional().describe('Configuration for the MongoD storage driver'),
+  root: z.string().optional().register(globalRegistry, {
+    description: 'Root directory for local storage',
+    title: 'storage.root',
+    type: 'string',
+  }),
 }).describe('Storage configuration options')
 
-export type StorageConfig = z.infer<typeof StorageConfigSchema>
+export type StorageConfig = z.infer<typeof StorageConfigZod>

package/src/config/storage/driver/Mongo.ts

@@ -1,5 +1,5 @@
 import { isDefined, isUndefined } from '@xylabs/typeof'
-import z from 'zod'
+import z, { globalRegistry } from 'zod'
 
 /**
  * Checks if the provided MongoDB configuration contains all necessary fields
@@ -19,13 +19,33 @@ export const hasMongoConfig = (config?: MongoConfig): config is Required<MongoCo
   )
 }
 
-export const MongoConfigSchema = z.object({
+export const MongoConfigZod = z.object({
   // TODO: Create from other arguments
-  connectionString: z.string().min(1).optional().describe('MongoDB connection string'),
-  database: z.string().min(1).optional().describe('MongoDB database name'),
-  domain: z.string().min(1).optional().describe('MongoDB domain'),
-  password: z.string().min(1).optional().describe('MongoDB password'),
-  username: z.string().min(1).optional().describe('MongoDB username'),
+  connectionString: z.string().min(1).optional().register(globalRegistry, {
+    description: 'MongoDB connection string',
+    title: 'storage.mongo.connectionString',
+    type: 'string',
+  }),
+  database: z.string().min(1).optional().register(globalRegistry, {
+    description: 'MongoDB database name',
+    title: 'storage.mongo.database',
+    type: 'string',
+  }),
+  domain: z.string().min(1).optional().register(globalRegistry, {
+    description: 'MongoDB domain',
+    title: 'storage.mongo.domain',
+    type: 'string',
+  }),
+  password: z.string().min(1).optional().register(globalRegistry, {
+    description: 'MongoDB password',
+    title: 'storage.mongo.password',
+    type: 'string',
+  }),
+  username: z.string().min(1).optional().register(globalRegistry, {
+    description: 'MongoDB username',
+    title: 'storage.mongo.username',
+    type: 'string',
+  }),
 })
 
-export type MongoConfig = z.infer<typeof MongoConfigSchema>
+export type MongoConfig = z.infer<typeof MongoConfigZod>

package/src/transaction/buildTransaction.ts

@@ -1,5 +1,5 @@
 import { assertEx } from '@xylabs/assert'
-import type { Address, Hex } from '@xylabs/hex'
+import type { Address } from '@xylabs/hex'
 import { toHex } from '@xylabs/hex'
 import type { AccountInstance } from '@xyo-network/account-model'
 import { BoundWitnessBuilder } from '@xyo-network/boundwitness-builder'
@@ -7,14 +7,15 @@ import { PayloadBuilder } from '@xyo-network/payload-builder'
 import type { Payload } from '@xyo-network/payload-model'
 import type {
   AllowedBlockPayload,
+  Chain,
   ExecutableFields,
   FromFields,
-  HydratedTransaction, TransactionBoundWitness, TransactionBoundWitnessFields, TransactionFeesBigInt,
+  SignedHydratedTransactionWithStorageMeta, TransactionBoundWitness, TransactionBoundWitnessFields, TransactionFeesBigInt,
 } from '@xyo-network/xl1-protocol'
 import { defaultTransactionFees } from '@xyo-network/xl1-protocol'
 
 export async function buildTransaction(
-  chain: Hex,
+  chain: Chain,
   onChainPayloads: AllowedBlockPayload[],
   offChainPayloads: Payload[],
   signer: AccountInstance | AccountInstance[],
@@ -22,7 +23,7 @@ export async function buildTransaction(
   exp: number,
   from?: Address,
   fees: TransactionFeesBigInt = defaultTransactionFees,
-): Promise<HydratedTransaction> {
+): Promise<SignedHydratedTransactionWithStorageMeta> {
   if (from === undefined && Array.isArray(signer)) {
     throw new Error('from is required when signer is an array')
   }

package/src/transaction/buildUnsignedTransaction.ts

@@ -1,25 +1,26 @@
-import type { Address, Hex } from '@xylabs/hex'
+import type { Address } from '@xylabs/hex'
 import { toHex } from '@xylabs/hex'
 import { BoundWitnessBuilder } from '@xyo-network/boundwitness-builder'
 import { PayloadBuilder } from '@xyo-network/payload-builder'
 import type { Payload } from '@xyo-network/payload-model'
 import type {
   AllowedBlockPayload,
+  Chain,
   ExecutableFields,
   FromFields,
-  HydratedTransaction, TransactionBoundWitness, TransactionBoundWitnessFields, TransactionFeesBigInt,
+  SignedHydratedTransactionWithStorageMeta, TransactionBoundWitness, TransactionBoundWitnessFields, TransactionFeesBigInt,
 } from '@xyo-network/xl1-protocol'
 import { defaultTransactionFees } from '@xyo-network/xl1-protocol'
 
 export async function buildUnsignedTransaction(
-  chain: Hex,
+  chain: Chain,
   onChainPayloads: AllowedBlockPayload[],
   offChainPayloads: Payload[],
   nbf: number,
   exp: number,
   from: Address,
   fees: TransactionFeesBigInt = defaultTransactionFees,
-): Promise<HydratedTransaction> {
+): Promise<SignedHydratedTransactionWithStorageMeta> {
   const txBoundWitnessFields: TransactionBoundWitnessFields = {
     chain,
     fees: {

package/src/transaction/hydrateTransaction.ts

@@ -5,44 +5,44 @@ import { hydrateTypedBoundWitness, tryHydrateTypedBoundWitness } from '@xyo-netw
 import type { Payload, WithStorageMeta } from '@xyo-network/payload-model'
 import type {
   AllowedBlockPayload,
-  HydratedTransaction, TransactionBoundWitness,
+  SignedHydratedTransaction, SignedHydratedTransactionWithStorageMeta, TransactionBoundWitness,
 } from '@xyo-network/xl1-protocol'
-import { isAllowedBlockPayload, isTransactionBoundWitnessWithStorageMeta } from '@xyo-network/xl1-protocol'
+import { isAllowedBlockPayload, isSignedTransactionBoundWitnessWithStorageMeta } from '@xyo-network/xl1-protocol'
 
 export const tryHydrateTransaction = async (
   archivist: ReadArchivist,
   hash: Hash,
-): Promise<HydratedTransaction | undefined> => {
+): Promise<SignedHydratedTransactionWithStorageMeta | undefined> => {
   return (await tryHydrateTypedBoundWitness<TransactionBoundWitness>(
     archivist,
     hash,
-    isTransactionBoundWitnessWithStorageMeta,
-  )) as HydratedTransaction | undefined
+    isSignedTransactionBoundWitnessWithStorageMeta,
+  )) as SignedHydratedTransactionWithStorageMeta | undefined
 }
 
 export const hydrateTransaction = async (
   archivist: ReadArchivist,
   hash: Hash,
-): Promise<HydratedTransaction> => {
+): Promise<SignedHydratedTransaction> => {
   return await hydrateTypedBoundWitness<TransactionBoundWitness>(
     archivist,
     hash,
-    isTransactionBoundWitnessWithStorageMeta,
-  ) as HydratedTransaction
+    isSignedTransactionBoundWitnessWithStorageMeta,
+  ) as SignedHydratedTransaction
 }
 
-export const flattenHydratedTransaction = (hydratedTransaction: HydratedTransaction): Payload[] => {
+export const flattenHydratedTransaction = (hydratedTransaction: SignedHydratedTransaction): Payload[] => {
   const [tx, txPayloads] = hydratedTransaction
   return [...txPayloads, tx]
 }
 
-export const flattenHydratedTransactions = (hydratedTransactions: HydratedTransaction[]): Payload[] =>
+export const flattenHydratedTransactions = (hydratedTransactions: SignedHydratedTransaction[]): Payload[] =>
   hydratedTransactions.flatMap(tx => flattenHydratedTransaction(tx))
 
 export const tryHydrateElevatedTransaction = async (
   archivist: ReadArchivist,
   hash: Hash,
-): Promise<HydratedTransaction | undefined> => {
+): Promise<SignedHydratedTransactionWithStorageMeta | undefined> => {
   const hydratedTransaction = await tryHydrateTransaction(archivist, hash)
   if (!hydratedTransaction) {
     return undefined
@@ -68,6 +68,6 @@ export const tryHydrateElevatedTransaction = async (
 export const hydrateElevatedTransaction = async (
   archivist: ReadArchivist,
   hash: Hash,
-): Promise<HydratedTransaction> => {
+): Promise<SignedHydratedTransaction> => {
   return assertEx(await tryHydrateElevatedTransaction(archivist, hash), () => 'Hydration failed')
 }

package/src/transaction/primitives/spec/transactionBlockByteCount.spec.ts

@@ -3,14 +3,14 @@ import type {
 } from '@xylabs/hex'
 import { PayloadBuilder } from '@xyo-network/payload-builder'
 import type { AnyPayload, Sequence } from '@xyo-network/payload-model'
-import type { HydratedTransaction, TransactionBoundWitness } from '@xyo-network/xl1-protocol'
+import type { SignedHydratedTransactionWithStorageMeta, TransactionBoundWitness } from '@xyo-network/xl1-protocol'
 import {
   describe, expect, it,
 } from 'vitest'
 
 import { transactionBlockByteCount } from '../transactionBlockByteCount.ts'
 
-const hydratedTransaction: HydratedTransaction<TransactionBoundWitness, AnyPayload> = [
+const hydratedTransaction: SignedHydratedTransactionWithStorageMeta<TransactionBoundWitness, AnyPayload> = [
   {
     schema: 'network.xyo.boundwitness',
     addresses: [
@@ -90,7 +90,7 @@ describe('transactionBlockByteCount', () => {
 
   it('handles transaction with empty payload array', () => {
     // Arrange
-    const emptyPayloadsTransaction: HydratedTransaction = [
+    const emptyPayloadsTransaction: SignedHydratedTransactionWithStorageMeta = [
       { ...hydratedTransaction[0] },
       [], // Empty payload array
     ]
@@ -122,7 +122,7 @@ describe('transactionBlockByteCount', () => {
       },
     })
 
-    const complexTransaction: HydratedTransaction = [
+    const complexTransaction: SignedHydratedTransactionWithStorageMeta = [
       { ...hydratedTransaction[0] },
       [complexPayload],
     ]
@@ -155,7 +155,7 @@ describe('transactionBlockByteCount', () => {
       _hash: `hash${i}`,
     })))
 
-    const largeTransaction: HydratedTransaction = [
+    const largeTransaction: SignedHydratedTransactionWithStorageMeta = [
       { ...hydratedTransaction[0] },
       largePayloads,
     ]
@@ -185,7 +185,7 @@ describe('transactionBlockByteCount', () => {
       _hash: 'special-hash',
     })
 
-    const specialTransaction: HydratedTransaction = [
+    const specialTransaction: SignedHydratedTransactionWithStorageMeta = [
       { ...hydratedTransaction[0] },
       [specialCharPayload],
     ]
@@ -219,7 +219,7 @@ describe('transactionBlockByteCount', () => {
       _extraMeta2: 'should be omitted as well',
     })
 
-    const transactionWithExtraMeta: HydratedTransaction = [
+    const transactionWithExtraMeta: SignedHydratedTransactionWithStorageMeta = [
       txWithExtraMeta,
       [payloadWithExtraMeta],
     ]

package/src/transaction/primitives/transactionBlockByteCount.ts

@@ -1,8 +1,8 @@
 import { PayloadBuilder } from '@xyo-network/payload-builder'
-import type { HydratedTransaction } from '@xyo-network/xl1-protocol'
+import type { SignedHydratedTransaction } from '@xyo-network/xl1-protocol'
 
 /** The number of bytes that a transaction and its payloads will take up in a block */
-export function transactionBlockByteCount([transaction, payloads]: HydratedTransaction): number {
+export function transactionBlockByteCount([transaction, payloads]: SignedHydratedTransaction): number {
   const cleanTransaction = PayloadBuilder.omitStorageMeta(transaction)
   const transactionBytes = JSON.stringify(cleanTransaction).length
   const cleanPayloads = PayloadBuilder.omitStorageMeta(payloads)

package/src/transaction/primitives/transactionElevatedPayloads.ts

@@ -1,6 +1,6 @@
 import { asHash, type Hash } from '@xylabs/hex'
 import type { Payload, WithHashStorageMeta } from '@xyo-network/payload-model'
-import type { HydratedTransaction, TransactionBoundWitness } from '@xyo-network/xl1-protocol'
+import type { SignedHydratedTransactionWithStorageMeta, TransactionBoundWitness } from '@xyo-network/xl1-protocol'
 
 import { crackOperations } from './transactionOperations.ts'
 
@@ -9,7 +9,7 @@ export function transactionElevatedPayloadHashes(transaction: TransactionBoundWi
   return elevateOperations.map(op => asHash(op[1][0], true))
 }
 
-export function transactionElevatedPayloads([transaction, payloads]: HydratedTransaction): WithHashStorageMeta<Payload>[] {
+export function transactionElevatedPayloads([transaction, payloads]: SignedHydratedTransactionWithStorageMeta): WithHashStorageMeta<Payload>[] {
   const hashes = transactionElevatedPayloadHashes(transaction)
   const elevatedPayloads = payloads.filter(payload => hashes.includes(payload._hash))
   return elevatedPayloads

package/src/transaction/primitives/transactionRequiredGas.ts

@@ -1,16 +1,16 @@
-import type { HydratedTransaction } from '@xyo-network/xl1-protocol'
+import type { SignedHydratedTransactionWithStorageMeta } from '@xyo-network/xl1-protocol'
 import { AttoXL1, TransactionGasCosts } from '@xyo-network/xl1-protocol'
 
 import { transactionBlockByteCount } from './transactionBlockByteCount.ts'
 import { transactionElevatedPayloads } from './transactionElevatedPayloads.ts'
 
 /** The required gas for the byte storage on the block chain for a transaction */
-export function transactionBytesRequiredGas([transaction, payloads]: HydratedTransaction): AttoXL1 {
+export function transactionBytesRequiredGas([transaction, payloads]: SignedHydratedTransactionWithStorageMeta): AttoXL1 {
   const transactionBlockBytes = transactionBlockByteCount([transaction, payloads])
   return AttoXL1(TransactionGasCosts.characterStorage * BigInt(transactionBlockBytes))
 }
 
-export function transactionRequiredGas(hydratedTransaction: HydratedTransaction): AttoXL1 {
+export function transactionRequiredGas(hydratedTransaction: SignedHydratedTransactionWithStorageMeta): AttoXL1 {
   const elevatedPayloads = transactionElevatedPayloads(hydratedTransaction)
   const hashes = elevatedPayloads.length + 1 /* for transaction itself */
   const signatures = hydratedTransaction[0].addresses.length

package/src/validation/schema/Mnemonic.ts

@@ -9,7 +9,7 @@ import { z } from 'zod'
  * • Checks that the word-count is 12, 15, 18, 21, or 24.
  *
  */
-export const MnemonicStringSchema = z
+export const MnemonicStringZod = z
   .string()
   .transform(s => s.trim().replaceAll(/\s+/g, ' ')) // normalize spacing
   .refine(
@@ -17,4 +17,4 @@ export const MnemonicStringSchema = z
     { message: 'Mnemonic must contain 12, 15, 18, 21, or 24 words.' },
   ).describe('BIP-39 mnemonic string')
 
-export type MnemonicString = z.infer<typeof MnemonicStringSchema>
+export type MnemonicString = z.infer<typeof MnemonicStringZod>