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

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "http://json.schemastore.org/package.json",
   "name": "@xyo-network/xl1-protocol-sdk",
-  "version": "1.10.2",
+  "version": "1.12.0",
   "description": "XYO Layer One SDK Protocol",
   "homepage": "https://xylabs.com",
   "bugs": {
@@ -36,28 +36,28 @@
     "src"
   ],
   "dependencies": {
-    "@xylabs/array": "~5.0.3",
-    "@xylabs/arraybuffer": "~5.0.3",
-    "@xylabs/assert": "~5.0.3",
-    "@xylabs/delay": "~5.0.3",
-    "@xylabs/hex": "~5.0.3",
-    "@xylabs/logger": "~5.0.3",
-    "@xylabs/object": "~5.0.3",
-    "@xylabs/promise": "~5.0.3",
-    "@xylabs/typeof": "~5.0.3",
-    "@xyo-network/account-model": "~5.0.1",
-    "@xyo-network/archivist-model": "~5.0.1",
-    "@xyo-network/boundwitness-builder": "~5.0.1",
-    "@xyo-network/boundwitness-model": "~5.0.1",
-    "@xyo-network/payload-builder": "~5.0.1",
-    "@xyo-network/payload-model": "~5.0.1",
-    "@xyo-network/wallet": "~5.0.1",
-    "@xyo-network/wallet-model": "~5.0.1",
-    "@xyo-network/xl1-protocol": "~1.9.3",
-    "zod": "~3.25.76"
+    "@xylabs/array": "~5.0.7",
+    "@xylabs/arraybuffer": "~5.0.7",
+    "@xylabs/assert": "~5.0.7",
+    "@xylabs/delay": "~5.0.7",
+    "@xylabs/hex": "~5.0.7",
+    "@xylabs/logger": "~5.0.7",
+    "@xylabs/object": "~5.0.7",
+    "@xylabs/promise": "~5.0.7",
+    "@xylabs/typeof": "~5.0.7",
+    "@xyo-network/account-model": "~5.0.2",
+    "@xyo-network/archivist-model": "~5.0.2",
+    "@xyo-network/boundwitness-builder": "~5.0.2",
+    "@xyo-network/boundwitness-model": "~5.0.2",
+    "@xyo-network/payload-builder": "~5.0.2",
+    "@xyo-network/payload-model": "~5.0.2",
+    "@xyo-network/wallet": "~5.0.2",
+    "@xyo-network/wallet-model": "~5.0.2",
+    "@xyo-network/xl1-protocol": "~1.10.12",
+    "zod": "~4.0.17"
   },
   "devDependencies": {
-    "@types/node": "~24.2.0",
+    "@types/node": "~24.2.1",
     "@xylabs/ts-scripts-yarn3": "~7.1.0",
     "@xylabs/tsconfig": "~7.1.0",
     "typescript": "~5.9.2",

package/src/config/Api.ts

@@ -1,11 +1,25 @@
-import z from 'zod'
+import z, { globalRegistry } from 'zod'
 
-import { MnemonicStringSchema } from '../validation/index.ts'
+import { MnemonicStringZod } from '../validation/index.ts'
 
-export const ApiConfigSchema = z.object({
-  mnemonic: MnemonicStringSchema.optional().describe('Mnemonic for the API wallet'),
-  host: z.string().default('localhost').describe('Host for the API'),
-  port: z.coerce.number().default(8080).describe('Port for the API'),
+export const ApiConfigZod = z.object({
+  host: z.string().default('localhost').register(globalRegistry, {
+    default: 'localhost',
+    description: 'Host for the API',
+    title: 'api.host',
+    type: 'string',
+  }),
+  mnemonic: MnemonicStringZod.optional().register(globalRegistry, {
+    description: 'Mnemonic for the API wallet',
+    title: 'api.mnemonic',
+    type: 'string',
+  }),
+  port: z.coerce.number().default(8080).register(globalRegistry, {
+    default: 8080,
+    description: 'Port for the API',
+    title: 'api.port',
+    type: 'number',
+  }),
 })
 
-export type ApiConfig = z.infer<typeof ApiConfigSchema>
+export type ApiConfig = z.infer<typeof ApiConfigZod>

package/src/config/App.ts

@@ -1,3 +1,12 @@
-import z from 'zod'
+import z, { globalRegistry } from 'zod'
 
-export const AppConfigSchema = z.object({ port: z.coerce.number().default(3000).describe('Port for the application') })
+export const AppConfigZod = z.object({
+  port: z.coerce.number().default(3000).register(globalRegistry, {
+    default: 3000,
+    description: 'Port for the application',
+    title: 'app.port',
+    type: 'number',
+  }),
+})
+
+export type AppConfig = z.infer<typeof AppConfigZod>

package/src/config/Chain.ts

@@ -1,6 +1,13 @@
-import z from 'zod'
+import z, { globalRegistry } from 'zod'
 
-export const ChainConfigSchema = z.object({
+export const ChainConfigZod = z.object({
   id: z.string().optional()
-    .describe('The unique identifier for the chain. Should be the staking contract address for contract-backed chains.'),
+    .register(globalRegistry, {
+      description:
+      'The unique identifier for the chain. Should be the staking contract address for contract-backed chains.',
+      title: 'chain.id',
+      type: 'string',
+    }),
 })
+
+export type ChainConfig = z.infer<typeof ChainConfigZod>

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/instances/transaction/HydratedTransaction.ts

@@ -1,10 +1,10 @@
-import type { AllowedBlockPayload, HydratedTransaction } from '@xyo-network/xl1-protocol'
+import type { AllowedBlockPayload, HydratedTransactionWithStorageMeta } from '@xyo-network/xl1-protocol'
 
 import type { HydratedBoundWitnessInstance } from '../HydratedBoundWitness.ts'
 import type { SignedInstance } from '../modifiers/index.ts'
 import type { TransactionFieldsInstance } from './TransactionFields.ts'
 
-export interface HydratedTransactionInstance<T extends HydratedTransaction = HydratedTransaction,
+export interface HydratedTransactionInstance<T extends HydratedTransactionWithStorageMeta = HydratedTransactionWithStorageMeta,
   TElevatedPayload extends AllowedBlockPayload = AllowedBlockPayload>
   extends TransactionFieldsInstance<T[1][number] & TElevatedPayload>, HydratedBoundWitnessInstance<T>, SignedInstance {
 }

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/confirmSubmittedTransaction.ts

@@ -4,7 +4,7 @@ import { isDefined } from '@xylabs/typeof'
 import type { Signed } from '@xyo-network/boundwitness-model'
 import { PayloadBuilder } from '@xyo-network/payload-builder'
 import type {
-  HydratedTransaction, TransactionBoundWitness, XyoViewer,
+  SignedHydratedTransaction, TransactionBoundWitness, XyoViewer,
 } from '@xyo-network/xl1-protocol'
 
 const DEFAULT_CONFIRMATION_ATTEMPTS = 20
@@ -38,7 +38,7 @@ export const confirmSubmittedTransaction = async (
   viewer: XyoViewer,
   transaction: Signed<TransactionBoundWitness>,
   options?: ConfirmSubmittedTransactionOptions,
-): Promise<HydratedTransaction> => {
+): Promise<SignedHydratedTransaction> => {
   const { attempts: maxAttempts = DEFAULT_CONFIRMATION_ATTEMPTS, delay: attemptDelay = DEFAULT_DELAY_BETWEEN_ATTEMPTS } = options || {}
   const txBWHash = await PayloadBuilder.hash(transaction)
   options?.logger?.log('🚀 confirming transaction:', txBWHash, '\n')

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')
 }