@xyo-network/xl1-protocol 1.14.7 → 1.14.9

package/dist/neutral/zod/TransactionBoundWitness.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TransactionBoundWitness.d.ts","sourceRoot":"","sources":["../../../src/zod/TransactionBoundWitness.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"TransactionBoundWitness.d.ts","sourceRoot":"","sources":["../../../src/zod/TransactionBoundWitness.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "http://json.schemastore.org/package.json",
   "name": "@xyo-network/xl1-protocol",
-  "version": "1.14.7",
+  "version": "1.14.9",
   "description": "XYO Layer One Protocol",
   "homepage": "https://xylabs.com",
   "bugs": {
@@ -40,39 +40,39 @@
   ],
   "dependencies": {
     "@opentelemetry/api": "~1.9.0",
-    "@xylabs/assert": "~5.0.39",
-    "@xylabs/error": "~5.0.39",
-    "@xylabs/hex": "~5.0.39",
-    "@xylabs/logger": "~5.0.39",
-    "@xylabs/object": "~5.0.39",
-    "@xylabs/promise": "~5.0.39",
-    "@xylabs/sdk-js": "~5.0.39",
-    "@xylabs/typeof": "~5.0.39",
-    "@xylabs/zod": "~5.0.39",
-    "@xyo-network/archivist-model": "~5.2.0",
-    "@xyo-network/boundwitness-model": "~5.2.0",
-    "@xyo-network/payload-model": "~5.2.0",
-    "@xyo-network/schema-payload-plugin": "~5.2.0",
+    "@xylabs/assert": "~5.0.41",
+    "@xylabs/error": "~5.0.41",
+    "@xylabs/hex": "~5.0.41",
+    "@xylabs/logger": "~5.0.41",
+    "@xylabs/object": "~5.0.41",
+    "@xylabs/promise": "~5.0.41",
+    "@xylabs/sdk-js": "~5.0.41",
+    "@xylabs/typeof": "~5.0.41",
+    "@xylabs/zod": "~5.0.41",
+    "@xyo-network/archivist-model": "~5.2.6",
+    "@xyo-network/boundwitness-model": "~5.2.6",
+    "@xyo-network/payload-model": "~5.2.6",
+    "@xyo-network/schema-payload-plugin": "~5.2.6",
     "zod": "~4.1.12"
   },
   "devDependencies": {
     "@types/node": "~24.10.1",
     "@typescript-eslint/types": "~8.47.0",
-    "@xylabs/creatable": "~5.0.39",
+    "@xylabs/creatable": "~5.0.41",
     "@xylabs/eslint-config-flat": "~7.2.8",
     "@xylabs/ts-scripts-yarn3": "~7.2.8",
     "@xylabs/tsconfig": "~7.2.8",
-    "@xyo-network/account-model": "~5.2.0",
-    "@xyo-network/payload-builder": "~5.2.0",
+    "@xyo-network/account-model": "~5.2.6",
+    "@xyo-network/payload-builder": "~5.2.6",
     "dependency-cruiser": "~17.3.1",
     "dotenv": "~17.2.3",
     "eslint": "~9.39.1",
     "eslint-import-resolver-typescript": "~4.4.4",
     "knip": "~5.70.1",
     "typescript": "~5.9.3",
-    "vite": "~7.2.2",
+    "vite": "~7.2.4",
     "vite-tsconfig-paths": "~5.1.4",
-    "vitest": "~4.0.10"
+    "vitest": "~4.0.12"
   },
   "packageManager": "yarn@4.10.3",
   "engines": {

package/src/model/BlockNumber/BlockNumber.ts

@@ -7,9 +7,11 @@ import { NumberishZod } from './Numberish.ts'
 export type BlockNumber = Brand<number, { readonly __blockNumber: true }>
 
 export const BlockNumberZod = z.number().transform(v => v as BlockNumber)
-export const NumberishBlockNumberZod = NumberishZod.transform(v => v as BlockNumber)
+export const BlockNumberishZod = NumberishZod.transform(v => v as BlockNumber)
+
+export type BlockNumberish = z.input<typeof BlockNumberishZod>
 
 export const asBlockNumber = zodAsFactory<BlockNumber>(BlockNumberZod, 'asBlockNumber')
-export const toBlockNumber = zodToFactory<BlockNumber>(NumberishBlockNumberZod, 'toBlockNumber')
+export const toBlockNumber = zodToFactory<BlockNumber>(BlockNumberishZod, 'toBlockNumber')
 
 export const BLOCK_NUMBER_ZERO = asBlockNumber(0)

package/src/model/BlockNumber/EthBlockNumber.ts

@@ -3,14 +3,16 @@ import { zodAsFactory, zodToFactory } from '@xylabs/zod'
 import z from 'zod'
 
 import type { BlockNumber } from './BlockNumber.ts'
-import { NumberishBlockNumberZod } from './BlockNumber.ts'
+import { BlockNumberishZod } from './BlockNumber.ts'
 
 export type EthBlockNumber = Brand<BlockNumber, { readonly __ethBlockNumber: true }>
 
 export const EthBlockNumberZod = z.number().transform(v => v as EthBlockNumber)
-export const NumberishEthBlockNumberZod = NumberishBlockNumberZod.transform(v => v as EthBlockNumber)
+export const EthBlockNumberishZod = BlockNumberishZod.transform(v => v as EthBlockNumber)
+
+export type EthBlockNumberish = z.input<typeof EthBlockNumberishZod>
 
 export const asEthBlockNumber = zodAsFactory<EthBlockNumber>(EthBlockNumberZod, 'asEthBlockNumber')
-export const toEthBlockNumber = zodToFactory<EthBlockNumber>(NumberishEthBlockNumberZod, 'toEthBlockNumber')
+export const toEthBlockNumber = zodToFactory<EthBlockNumber>(EthBlockNumberishZod, 'toEthBlockNumber')
 
 export const ETH_BLOCK_NUMBER_ZERO = asEthBlockNumber(0)

package/src/model/BlockNumber/Numberish.ts

@@ -3,3 +3,5 @@ import z from 'zod'
 export const NumberishZod = z.union([z.number(), z.string(), z.bigint()])
   .transform(v => (typeof v === 'bigint' ? Number(v) : typeof v === 'string' ? Number(v) : v))
   .pipe(z.number())
+
+export type Numberish = z.input<typeof NumberishZod>

package/src/model/BlockNumber/XL1BlockNumber.ts

@@ -3,14 +3,16 @@ import { zodAsFactory, zodToFactory } from '@xylabs/zod'
 import z from 'zod'
 
 import type { BlockNumber } from './BlockNumber.ts'
-import { NumberishBlockNumberZod } from './BlockNumber.ts'
+import { BlockNumberishZod } from './BlockNumber.ts'
 
 export type XL1BlockNumber = Brand<BlockNumber, { readonly __xl1BlockNumber: true }>
 
 export const XL1BlockNumberZod = z.number().transform(v => v as XL1BlockNumber)
-export const NumberishXL1BlockNumberZod = NumberishBlockNumberZod.transform(v => v as XL1BlockNumber)
+export const XL1BlockNumberishZod = BlockNumberishZod.transform(v => v as XL1BlockNumber)
+
+export type XL1BlockNumberish = z.input<typeof XL1BlockNumberishZod>
 
 export const asXL1BlockNumber = zodAsFactory<XL1BlockNumber>(XL1BlockNumberZod, 'asXL1BlockNumber')
-export const toXL1BlockNumber = zodToFactory<XL1BlockNumber>(NumberishXL1BlockNumberZod, 'toXL1BlockNumber')
+export const toXL1BlockNumber = zodToFactory<XL1BlockNumber>(XL1BlockNumberishZod, 'toXL1BlockNumber')
 
 export const XL1_BLOCK_NUMBER_ZERO = asXL1BlockNumber(0)

package/src/model/BlockRange/BlockRange.ts

@@ -6,17 +6,19 @@ import z from 'zod'
 
 import {
   asBlockNumber,
-  type BlockNumber, BlockNumberZod, NumberishBlockNumberZod,
+  type BlockNumber, BlockNumberishZod,
+  BlockNumberZod,
 } from '../BlockNumber/index.ts'
 
 export type BlockRange = [BlockNumber, BlockNumber]
-export type NumberishBlockRange = [BlockNumber, BlockNumber]
 
 export const BlockRangeZod = z.tuple([BlockNumberZod, BlockNumberZod])
-export const NumberishBlockRangeZod = z.tuple([NumberishBlockNumberZod, NumberishBlockNumberZod])
+export const BlockRangeishZod = z.tuple([BlockNumberishZod, BlockNumberishZod])
+
+export type BlockRangeish = z.input<typeof BlockRangeishZod>
 
 export const asBlockRange = zodAsFactory<BlockRange>(BlockRangeZod, 'BlockRange')
-export const toBlockRange = zodToFactory<BlockRange>(NumberishBlockRangeZod, 'BlockRange')
+export const toBlockRange = zodToFactory<BlockRange>(BlockRangeishZod, 'BlockRange')
 
 export type BlockRangeKey = Brand<string, { readonly __blockRangeKey: true }>
 export const toBlockNumberKey = (range: BlockRange) => `${range[0]}|${range[1]}` as BlockRangeKey

package/src/model/BlockRange/EthBlockRange.ts

@@ -7,18 +7,19 @@ import z from 'zod'
 import type { EthBlockNumber } from '../BlockNumber/index.ts'
 import {
   asEthBlockNumber,
+  EthBlockNumberishZod,
   EthBlockNumberZod,
-  NumberishEthBlockNumberZod,
 } from '../BlockNumber/index.ts'
 
 export type EthBlockRange = [EthBlockNumber, EthBlockNumber]
-export type NumberishEthBlockRange = [EthBlockNumber, EthBlockNumber]
 
 export const EthBlockRangeZod = z.tuple([EthBlockNumberZod, EthBlockNumberZod])
-export const NumberishEthBlockRangeZod = z.tuple([NumberishEthBlockNumberZod, NumberishEthBlockNumberZod])
+export const EthBlockRangeishZod = z.tuple([EthBlockNumberishZod, EthBlockNumberishZod])
+
+export type EthBlockRangeish = z.input<typeof EthBlockRangeishZod>
 
 export const asEthBlockRange = zodAsFactory<EthBlockRange>(EthBlockRangeZod, 'EthBlockRange')
-export const toEthBlockRange = zodToFactory<EthBlockRange>(NumberishEthBlockRangeZod, 'EthBlockRange')
+export const toEthBlockRange = zodToFactory<EthBlockRange>(EthBlockRangeishZod, 'EthBlockRange')
 
 export type EthBlockRangeKey = Brand<string, { readonly __ethBlockRangeKey: true }>
 export const toEthBlockNumberKey = (range: EthBlockRange) => `${range[0]}|${range[1]}` as EthBlockRangeKey

package/src/model/BlockRange/XL1BlockRange.ts

@@ -7,18 +7,19 @@ import z from 'zod'
 import type { XL1BlockNumber } from '../BlockNumber/index.ts'
 import {
   asXL1BlockNumber,
-  NumberishXL1BlockNumberZod,
+  XL1BlockNumberishZod,
   XL1BlockNumberZod,
 } from '../BlockNumber/index.ts'
 
 export type XL1BlockRange = [XL1BlockNumber, XL1BlockNumber]
-export type NumberishXL1BlockRange = [XL1BlockNumber, XL1BlockNumber]
 
 export const XL1BlockRangeZod = z.tuple([XL1BlockNumberZod, XL1BlockNumberZod])
-export const NumberishXL1BlockRangeZod = z.tuple([NumberishXL1BlockNumberZod, NumberishXL1BlockNumberZod])
+export const XL1BlockRangeishZod = z.tuple([XL1BlockNumberishZod, XL1BlockNumberishZod])
+
+export type XL1BlockRangeish = z.input<typeof XL1BlockRangeishZod>
 
 export const asXL1BlockRange = zodAsFactory<XL1BlockRange>(XL1BlockRangeZod, 'XL1BlockRange')
-export const toXL1BlockRange = zodToFactory<XL1BlockRange>(NumberishXL1BlockRangeZod, 'XL1BlockRange')
+export const toXL1BlockRange = zodToFactory<XL1BlockRange>(XL1BlockRangeishZod, 'XL1BlockRange')
 
 export type XL1BlockRangeKey = Brand<string, { readonly __xl1BlockRangeKey: true }>
 export const toXL1BlockNumberKey = (range: XL1BlockRange) => `${range[0]}|${range[1]}` as XL1BlockRangeKey

package/src/model/ChainId.ts

@@ -1,3 +1,3 @@
-import type { Address, Hex } from '@xylabs/hex'
+import type { Hex } from '@xylabs/hex'
 
-export type ChainId = Address | Hex
+export type ChainId = Hex

package/src/model/GatewayName.ts

@@ -1 +1,3 @@
-export type GatewayName = string & { __gatewayName: true }
+import type { Brand } from '@xylabs/typeof'
+
+export type GatewayName = Brand<string, { __gatewayName: true }>

package/src/validation/payload/InBlockPayloadValidationFunction.ts

@@ -1,9 +1,9 @@
 import type { Promisable } from '@xylabs/promise'
 import type { Payload, WithHashMeta } from '@xyo-network/payload-model'
 
-import type { HydratedBlock } from '../../zod/index.ts'
+import type { HydratedBlockWithHashMeta } from '../../zod/index.ts'
 import type { InBlockPayloadValidationError } from './error.ts'
 
 export type InBlockPayloadValidationFunction = (
-  payload: WithHashMeta<Payload>, block: HydratedBlock,
+  payload: WithHashMeta<Payload>, block: HydratedBlockWithHashMeta,
 ) => Promisable<InBlockPayloadValidationError[]>

package/src/zod/BlockBoundWitness.ts

@@ -24,8 +24,8 @@ export const BlockBoundWitnessFieldsZod = z.object({
 export const BlockBoundWitnessMetaZod = z.object({ $epoch: z.number() })
 
 export const BlockBoundWitnessZod = BoundWitnessZod
-  .extend(BlockBoundWitnessFieldsZod.shape)
-  .extend(BlockBoundWitnessMetaZod.shape)
+  .safeExtend(BlockBoundWitnessFieldsZod.shape)
+  .safeExtend(BlockBoundWitnessMetaZod.shape)
 
 export type BlockBoundWitness = z.infer<typeof BlockBoundWitnessZod>
 
@@ -34,7 +34,7 @@ export const asBlockBoundWitness = zodAsFactory(BlockBoundWitnessZod, 'asBlockBo
 export const toBlockBoundWitness = zodToFactory(BlockBoundWitnessZod, 'toBlockBoundWitness')
 
 export const BlockBoundWitnessWithHashMetaZod = BlockBoundWitnessZod
-  .extend(HashMetaZod.shape)
+  .safeExtend(HashMetaZod.shape)
 
 export type BlockBoundWitnessWithHashMeta = z.infer<typeof BlockBoundWitnessWithHashMetaZod>
 
@@ -43,7 +43,7 @@ export const asBlockBoundWitnessWithHashMeta = zodAsFactory(BlockBoundWitnessWit
 export const toBlockBoundWitnessWithHashMeta = zodToFactory(BlockBoundWitnessWithHashMetaZod, 'toBlockBoundWitnessWithHashMeta')
 
 export const BlockBoundWitnessWithStorageMetaZod = BlockBoundWitnessZod
-  .extend(StorageMetaZod.shape)
+  .safeExtend(StorageMetaZod.shape)
 
 export type BlockBoundWitnessWithStorageMeta = z.infer<typeof BlockBoundWitnessWithStorageMetaZod>
 
@@ -52,8 +52,8 @@ export const asBlockBoundWitnessWithStorageMeta = zodAsFactory(BlockBoundWitness
 export const toBlockBoundWitnessWithStorageMeta = zodToFactory(BlockBoundWitnessWithStorageMetaZod, 'toBlockBoundWitnessWithStorageMeta')
 
 export const UnsignedBlockBoundWitnessZod = UnsignedBoundWitnessZod
-  .extend(BlockBoundWitnessFieldsZod.shape)
-  .extend(BlockBoundWitnessMetaZod.shape)
+  .safeExtend(BlockBoundWitnessFieldsZod.shape)
+  .safeExtend(BlockBoundWitnessMetaZod.shape)
 
 export type UnsignedBlockBoundWitness = z.infer<typeof UnsignedBlockBoundWitnessZod>
 
@@ -61,7 +61,7 @@ export const isUnsignedBlockBoundWitness = zodIsFactory(UnsignedBlockBoundWitnes
 export const asUnsignedBlockBoundWitness = zodAsFactory(UnsignedBlockBoundWitnessZod, 'asUnsignedBlockBoundWitness')
 export const toUnsignedBlockBoundWitness = zodToFactory(UnsignedBlockBoundWitnessZod, 'toUnsignedBlockBoundWitness')
 
-export const UnsignedBlockBoundWitnessWithHashMetaZod = UnsignedBlockBoundWitnessZod.extend(HashMetaZod.shape)
+export const UnsignedBlockBoundWitnessWithHashMetaZod = UnsignedBlockBoundWitnessZod.safeExtend(HashMetaZod.shape)
 
 export type UnsignedBlockBoundWitnessWithHashMeta = z.infer<typeof UnsignedBlockBoundWitnessWithHashMetaZod>
 
@@ -69,7 +69,7 @@ export const isUnsignedBlockBoundWitnessWithHashMeta = zodIsFactory(UnsignedBloc
 export const asUnsignedBlockBoundWitnessWithHashMeta = zodAsFactory(UnsignedBlockBoundWitnessWithHashMetaZod, 'asUnsignedBlockBoundWitnessWithHashMeta')
 export const toUnsignedBlockBoundWitnessWithHashMeta = zodToFactory(UnsignedBlockBoundWitnessWithHashMetaZod, 'toUnsignedBlockBoundWitnessWithHashMeta')
 
-export const UnsignedBlockBoundWitnessWithStorageMetaZod = UnsignedBlockBoundWitnessZod.extend(StorageMetaZod.shape)
+export const UnsignedBlockBoundWitnessWithStorageMetaZod = UnsignedBlockBoundWitnessZod.safeExtend(StorageMetaZod.shape)
 
 export type UnsignedBlockBoundWitnessWithStorageMeta = z.infer<typeof UnsignedBlockBoundWitnessWithStorageMetaZod>
 
@@ -84,8 +84,8 @@ export const toUnsignedBlockBoundWitnessWithStorageMeta = zodToFactory(
 )
 
 export const SignedBlockBoundWitnessZod = SignedBoundWitnessZod
-  .extend(BlockBoundWitnessFieldsZod.shape)
-  .extend(BlockBoundWitnessMetaZod.shape)
+  .safeExtend(BlockBoundWitnessFieldsZod.shape)
+  .safeExtend(BlockBoundWitnessMetaZod.shape)
 
 export type SignedBlockBoundWitness = z.infer<typeof SignedBlockBoundWitnessZod>
 
@@ -93,7 +93,7 @@ export const isSignedBlockBoundWitness = zodIsFactory(SignedBlockBoundWitnessZod
 export const asSignedBlockBoundWitness = zodAsFactory(SignedBlockBoundWitnessZod, 'asSignedBlockBoundWitness')
 export const toSignedBlockBoundWitness = zodToFactory(SignedBlockBoundWitnessZod, 'toSignedBlockBoundWitness')
 
-export const SignedBlockBoundWitnessWithHashMetaZod = SignedBlockBoundWitnessZod.extend(HashMetaZod.shape)
+export const SignedBlockBoundWitnessWithHashMetaZod = SignedBlockBoundWitnessZod.safeExtend(HashMetaZod.shape)
 
 export type SignedBlockBoundWitnessWithHashMeta = z.infer<typeof SignedBlockBoundWitnessWithHashMetaZod>
 
@@ -101,7 +101,7 @@ export const isSignedBlockBoundWitnessWithHashMeta = zodIsFactory(SignedBlockBou
 export const asSignedBlockBoundWitnessWithHashMeta = zodAsFactory(SignedBlockBoundWitnessWithHashMetaZod, 'asSignedBlockBoundWitnessWithHashMeta')
 export const toSignedBlockBoundWitnessWithHashMeta = zodToFactory(SignedBlockBoundWitnessWithHashMetaZod, 'toSignedBlockBoundWitnessWithHashMeta')
 
-export const SignedBlockBoundWitnessWithStorageMetaZod = SignedBlockBoundWitnessZod.extend(StorageMetaZod.shape)
+export const SignedBlockBoundWitnessWithStorageMetaZod = SignedBlockBoundWitnessZod.safeExtend(StorageMetaZod.shape)
 
 export type SignedBlockBoundWitnessWithStorageMeta = z.infer<typeof SignedBlockBoundWitnessWithStorageMetaZod>
 

package/src/zod/BoundWitness.ts

@@ -21,10 +21,9 @@ const BoundWitnessMetaZod = z.object({
 })
 
 export const BoundWitnessZod = PayloadZod
-  .extend({ schema: z.literal(BoundWitnessSchema) })
-  .extend(BoundWitnessRequiredFieldsZod.shape)
-  .extend(BoundWitnessMetaZod.shape)
-  .refine(data => data.$signatures.length === data.addresses.length, { message: '$signatures length must equal addresses length' })
+  .safeExtend({ schema: z.literal(BoundWitnessSchema) })
+  .safeExtend(BoundWitnessRequiredFieldsZod.shape)
+  .safeExtend(BoundWitnessMetaZod.shape)
 
 export type BoundWitness = z.infer<typeof BoundWitnessZod>
 

package/src/zod/Permission.ts

@@ -13,7 +13,7 @@ export const PermissionZod = z.object({
   invoker: z.string(),
 })
 
-export const InvokerPermissionZod = PermissionZod.extend({ date: z.number().optional() })
+export const InvokerPermissionZod = PermissionZod.safeExtend({ date: z.number().optional() })
 
 export const PermissionRequestZod = z.record(z.string(), z.record(z.string(), z.any()))
 

package/src/zod/Stake.ts

@@ -32,6 +32,7 @@ export const StakeToJsonZod = StakeZod.transform(val => ({
   withdrawBlock: val.withdrawBlock,
 }))
 
+// we intentionally use extend and not safeExtend here to ensure all fields are present
 export const JsonToStakeZod = StakeZod.extend({ amount: HexZod }).transform(val => ({
   addBlock: val.addBlock,
   amount: JsonToAttoZod.parse(val.amount),

package/src/zod/TransactionBoundWitness.ts

@@ -5,16 +5,16 @@ import {
 import { HashMetaZod, StorageMetaZod } from '@xyo-network/payload-model'
 import * as z from 'zod'
 
-import { BlockNumberZod } from '../model/index.ts'
+import { XL1BlockNumberZod } from '../model/index.ts'
 import {
   BoundWitnessZod, SignedBoundWitnessZod, UnsignedBoundWitnessZod,
 } from './BoundWitness.ts'
 import { ChainZod } from './Chain.ts'
 import { TransactionFeesHexZod } from './TransactionFees.ts'
 
-export const BlockStartZod = z.object({ nbf: BlockNumberZod })
-export const BlockEndZod = z.object({ exp: BlockNumberZod })
-export const BlockDurationZod = z.object({ nbf: BlockNumberZod, exp: BlockNumberZod })
+export const BlockStartZod = z.object({ nbf: XL1BlockNumberZod })
+export const BlockEndZod = z.object({ exp: XL1BlockNumberZod })
+export const BlockDurationZod = z.object({ nbf: XL1BlockNumberZod, exp: XL1BlockNumberZod })
 export const BlockScriptsZod = z.object({ script: z.array(z.string()).optional() })
 
 export const TransactionFeesZod = z.object({ fees: TransactionFeesHexZod })
@@ -22,15 +22,15 @@ export const TransactionFeesZod = z.object({ fees: TransactionFeesHexZod })
 export const TransactionBoundWitnessIdentityFields = z.object({ chain: ChainZod, from: AddressZod })
 
 export const TransactionBoundWitnessFieldsZod = z.object()
-  .extend(BlockDurationZod.shape)
-  .extend(TransactionFeesZod.shape)
-  .extend(TransactionBoundWitnessIdentityFields.shape)
-  .extend(BlockScriptsZod.shape)
+  .safeExtend(BlockDurationZod.shape)
+  .safeExtend(TransactionFeesZod.shape)
+  .safeExtend(TransactionBoundWitnessIdentityFields.shape)
+  .safeExtend(BlockScriptsZod.shape)
 
 export type TransactionBoundWitnessFields = z.infer<typeof TransactionBoundWitnessFieldsZod>
 
 export const TransactionBoundWitnessZod = BoundWitnessZod
-  .extend(TransactionBoundWitnessFieldsZod.shape)
+  .safeExtend(TransactionBoundWitnessFieldsZod.shape)
 
 export type TransactionBoundWitness = z.infer<typeof TransactionBoundWitnessZod>
 
@@ -39,7 +39,7 @@ export const asTransactionBoundWitness = zodAsFactory(TransactionBoundWitnessZod
 export const toTransactionBoundWitness = zodToFactory(TransactionBoundWitnessZod, 'toTransactionBoundWitness')
 
 export const TransactionBoundWitnessWithHashMetaZod = TransactionBoundWitnessZod
-  .extend(HashMetaZod.shape)
+  .safeExtend(HashMetaZod.shape)
 
 export type TransactionBoundWitnessWithHashMeta = z.infer<typeof TransactionBoundWitnessWithHashMetaZod>
 
@@ -48,7 +48,7 @@ export const asTransactionBoundWitnessWithHashMeta = zodAsFactory(TransactionBou
 export const toTransactionBoundWitnessWithHashMeta = zodToFactory(TransactionBoundWitnessWithHashMetaZod, 'toTransactionBoundWitnessWithHashMeta')
 
 export const TransactionBoundWitnessWithStorageMetaZod = TransactionBoundWitnessZod
-  .extend(StorageMetaZod.shape)
+  .safeExtend(StorageMetaZod.shape)
 
 export type TransactionBoundWitnessWithStorageMeta = z.infer<typeof TransactionBoundWitnessWithStorageMetaZod>
 
@@ -57,7 +57,7 @@ export const asTransactionBoundWitnessWithStorageMeta = zodAsFactory(Transaction
 export const toTransactionBoundWitnessWithStorageMeta = zodToFactory(TransactionBoundWitnessWithStorageMetaZod, 'toTransactionBoundWitnessWithStorageMeta')
 
 export const UnsignedTransactionBoundWitnessZod = UnsignedBoundWitnessZod
-  .extend(TransactionBoundWitnessFieldsZod.shape)
+  .safeExtend(TransactionBoundWitnessFieldsZod.shape)
 
 export type UnsignedTransactionBoundWitness = z.infer<typeof UnsignedTransactionBoundWitnessZod>
 
@@ -65,7 +65,7 @@ export const isUnsignedTransactionBoundWitness = zodIsFactory(UnsignedTransactio
 export const asUnsignedTransactionBoundWitness = zodAsFactory(UnsignedTransactionBoundWitnessZod, 'asUnsignedTransactionBoundWitness')
 export const toUnsignedTransactionBoundWitness = zodToFactory(UnsignedTransactionBoundWitnessZod, 'toUnsignedTransactionBoundWitness')
 
-export const UnsignedTransactionBoundWitnessWithHashMetaZod = UnsignedTransactionBoundWitnessZod.extend(HashMetaZod.shape)
+export const UnsignedTransactionBoundWitnessWithHashMetaZod = UnsignedTransactionBoundWitnessZod.safeExtend(HashMetaZod.shape)
 
 export type UnsignedTransactionBoundWitnessWithHashMeta = z.infer<typeof UnsignedTransactionBoundWitnessWithHashMetaZod>
 
@@ -80,7 +80,7 @@ export const toUnsignedTransactionBoundWitnessWithHashMeta = zodToFactory(
 )
 
 export const UnsignedTransactionBoundWitnessWithStorageMetaZod = UnsignedTransactionBoundWitnessZod
-  .extend(StorageMetaZod.shape)
+  .safeExtend(StorageMetaZod.shape)
 
 export type UnsignedTransactionBoundWitnessWithStorageMeta = z.infer<typeof UnsignedTransactionBoundWitnessWithStorageMetaZod>
 
@@ -95,7 +95,7 @@ export const toUnsignedTransactionBoundWitnessWithStorageMeta = zodToFactory(
 )
 
 export const SignedTransactionBoundWitnessZod = SignedBoundWitnessZod
-  .extend(TransactionBoundWitnessFieldsZod.shape)
+  .safeExtend(TransactionBoundWitnessFieldsZod.shape)
 
 export type SignedTransactionBoundWitness = z.infer<typeof SignedTransactionBoundWitnessZod>
 
@@ -104,7 +104,7 @@ export const asSignedTransactionBoundWitness = zodAsFactory(SignedTransactionBou
 export const toSignedTransactionBoundWitness = zodToFactory(SignedTransactionBoundWitnessZod, 'toSignedTransactionBoundWitness')
 
 export const SignedTransactionBoundWitnessWithHashMetaZod = SignedTransactionBoundWitnessZod
-  .extend(HashMetaZod.shape)
+  .safeExtend(HashMetaZod.shape)
 
 export type SignedTransactionBoundWitnessWithHashMeta = z.infer<typeof SignedTransactionBoundWitnessWithHashMetaZod>
 
@@ -119,7 +119,7 @@ export const toSignedTransactionBoundWitnessWithHashMeta = zodToFactory(
 )
 
 export const SignedTransactionBoundWitnessWithStorageMetaZod = SignedTransactionBoundWitnessZod
-  .extend(StorageMetaZod.shape)
+  .safeExtend(StorageMetaZod.shape)
 
 export type SignedTransactionBoundWitnessWithStorageMeta = z.infer<typeof SignedTransactionBoundWitnessWithStorageMetaZod>