@xyo-network/xl1-protocol 1.25.32 → 1.26.1

package/src/block/HydratedBlock.ts

@@ -1,135 +0,0 @@
-import {
-  zodAsFactory, zodIsFactory, zodToFactory,
-} from '@xylabs/sdk-js'
-import {
-  PayloadZod,
-  PayloadZodLoose, WithHashMetaZod, WithStorageMetaZod,
-} from '@xyo-network/sdk-js'
-import { z } from 'zod'
-
-import { BlockBoundWitnessZod } from './BlockBoundWitness.ts'
-import { SignedBlockBoundWitnessZod } from './signed/index.ts'
-
-/** HydratedBlockZod constant. */
-export const HydratedBlockZod = z.tuple([
-  BlockBoundWitnessZod,
-  z.array(PayloadZodLoose),
-])
-
-/** Type representing a hydrated Block with resolved payloads. */
-export type HydratedBlock = z.infer<typeof HydratedBlockZod>
-
-/** Type guard that checks if a value is a valid HydratedBlock. */
-export const isHydratedBlock = zodIsFactory(HydratedBlockZod)
-/** Converts a value to HydratedBlock, throwing if invalid. */
-export const asHydratedBlock = zodAsFactory(HydratedBlockZod, 'asHydratedBlock')
-/** toHydratedBlock constant. */
-export const toHydratedBlock = zodToFactory(HydratedBlockZod, 'toHydratedBlock')
-
-/** HydratedBlockWithHashMetaZod constant. */
-export const HydratedBlockWithHashMetaZod = z.tuple([
-  WithHashMetaZod(BlockBoundWitnessZod),
-  z.array(WithHashMetaZod(PayloadZod).loose()),
-])
-
-/** Type representing a hydrated BlockWithHashMeta with resolved payloads. */
-export type HydratedBlockWithHashMeta = z.infer<typeof HydratedBlockWithHashMetaZod>
-
-/** Type guard that checks if a value is a valid HydratedBlockWithHashMeta. */
-export const isHydratedBlockWithHashMeta = zodIsFactory(HydratedBlockWithHashMetaZod)
-/** Converts a value to HydratedBlockWithHashMeta, throwing if invalid. */
-export const asHydratedBlockWithHashMeta = zodAsFactory(HydratedBlockWithHashMetaZod, 'asHydratedBlockWithHashMeta')
-/** toHydratedBlockWithHashMeta constant. */
-export const toHydratedBlockWithHashMeta = zodToFactory(HydratedBlockWithHashMetaZod, 'toHydratedBlockWithHashMeta')
-
-/** HydratedBlockWithStorageMetaZod constant. */
-export const HydratedBlockWithStorageMetaZod = z.tuple([
-  WithStorageMetaZod(BlockBoundWitnessZod),
-  z.array(WithStorageMetaZod(PayloadZod).loose()),
-])
-
-/** Type representing a hydrated BlockWithStorageMeta with resolved payloads. */
-export type HydratedBlockWithStorageMeta = z.infer<typeof HydratedBlockWithStorageMetaZod>
-
-/** Type guard that checks if a value is a valid HydratedBlockWithStorageMeta. */
-export const isHydratedBlockWithStorageMeta = zodIsFactory(HydratedBlockWithStorageMetaZod)
-/** Converts a value to HydratedBlockWithStorageMeta, throwing if invalid. */
-export const asHydratedBlockWithStorageMeta = zodAsFactory(HydratedBlockWithStorageMetaZod, 'asHydratedBlockWithStorageMeta')
-/** toHydratedBlockWithStorageMeta constant. */
-export const toHydratedBlockWithStorageMeta = zodToFactory(HydratedBlockWithStorageMetaZod, 'toHydratedBlockWithStorageMeta')
-
-/** SignedHydratedBlockZod constant. */
-export const SignedHydratedBlockZod = z.tuple([
-  SignedBlockBoundWitnessZod,
-  z.array(PayloadZod.loose()),
-])
-
-/** Type representing a hydrated SignedBlock with resolved payloads. */
-export type SignedHydratedBlock = z.infer<typeof SignedHydratedBlockZod>
-
-/** Type guard that checks if a value is a valid SignedHydratedBlock. */
-export const isSignedHydratedBlock = zodIsFactory(SignedHydratedBlockZod)
-/** Converts a value to SignedHydratedBlock, throwing if invalid. */
-export const asSignedHydratedBlock = zodAsFactory(SignedHydratedBlockZod, 'asSignedHydratedBlock')
-/** toSignedHydratedBlock constant. */
-export const toSignedHydratedBlock = zodToFactory(SignedHydratedBlockZod, 'toSignedHydratedBlock')
-
-/** SignedHydratedBlockToJsonZod constant. */
-export const SignedHydratedBlockToJsonZod = z.tuple([
-  SignedBlockBoundWitnessZod,
-  z.array(PayloadZod.loose()),
-])
-
-/** Type representing a hydrated SignedBlockToJson with resolved payloads. */
-export type SignedHydratedBlockToJson = z.infer<typeof SignedHydratedBlockToJsonZod>
-
-/** Type guard that checks if a value is a valid SignedHydratedBlockToJson. */
-export const isSignedHydratedBlockToJson = zodIsFactory(SignedHydratedBlockToJsonZod)
-/** Converts a value to SignedHydratedBlockToJson, throwing if invalid. */
-export const asSignedHydratedBlockToJson = zodAsFactory(SignedHydratedBlockToJsonZod, 'asSignedHydratedBlockToJson')
-/** toSignedHydratedBlockToJson constant. */
-export const toSignedHydratedBlockToJson = zodToFactory(SignedHydratedBlockToJsonZod, 'toSignedHydratedBlockToJson')
-
-/** SignedHydratedBlockWithHashMetaZod constant. */
-export const SignedHydratedBlockWithHashMetaZod = z.tuple([
-  WithHashMetaZod(SignedBlockBoundWitnessZod),
-  z.array(WithHashMetaZod(PayloadZod).loose()),
-])
-
-/** Type representing a hydrated SignedBlockWithHashMeta with resolved payloads. */
-export type SignedHydratedBlockWithHashMeta = z.infer<typeof SignedHydratedBlockWithHashMetaZod>
-
-/** SignedHydratedBlockWithHashMetaishZod constant. */
-export const SignedHydratedBlockWithHashMetaishZod = z.tuple([
-  z.union([WithHashMetaZod(SignedBlockBoundWitnessZod)]),
-  z.array(WithHashMetaZod(PayloadZod).loose()),
-])
-
-/** Type guard that checks if a value is a valid SignedHydratedBlockWithHashMeta. */
-export const isSignedHydratedBlockWithHashMeta = zodIsFactory(SignedHydratedBlockWithHashMetaZod)
-/** Converts a value to SignedHydratedBlockWithHashMeta, throwing if invalid. */
-export const asSignedHydratedBlockWithHashMeta = zodAsFactory(SignedHydratedBlockWithHashMetaZod, 'asSignedHydratedBlockWithHashMeta')
-
-/** toSignedHydratedBlockWithHashMeta constant. */
-export const toSignedHydratedBlockWithHashMeta = zodToFactory(SignedHydratedBlockWithHashMetaZod, 'toSignedHydratedBlockWithHashMeta')
-
-/** SignedHydratedBlockWithStorageMetaZod constant. */
-export const SignedHydratedBlockWithStorageMetaZod = z.tuple([
-  WithStorageMetaZod(SignedBlockBoundWitnessZod),
-  z.array(WithStorageMetaZod(PayloadZod).loose()),
-])
-/** Type representing a hydrated SignedBlockWithStorageMeta with resolved payloads. */
-export type SignedHydratedBlockWithStorageMeta = z.infer<typeof SignedHydratedBlockWithStorageMetaZod>
-
-/** Type guard that checks if a value is a valid SignedHydratedBlockWithStorageMeta. */
-export const isSignedHydratedBlockWithStorageMeta = zodIsFactory(SignedHydratedBlockWithStorageMetaZod)
-/** Converts a value to SignedHydratedBlockWithStorageMeta, throwing if invalid. */
-export const asSignedHydratedBlockWithStorageMeta = zodAsFactory(SignedHydratedBlockWithStorageMetaZod, 'asSignedHydratedBlockWithStorageMeta')
-/** toSignedHydratedBlockWithStorageMeta constant. */
-export const toSignedHydratedBlockWithStorageMeta = zodToFactory(SignedHydratedBlockWithStorageMetaZod, 'toSignedHydratedBlockWithStorageMeta')
-
-/** SignedHydratedBlockWithStorageMetaishZod constant. */
-export const SignedHydratedBlockWithStorageMetaishZod = z.tuple([
-  z.union([WithStorageMetaZod(SignedBlockBoundWitnessZod)]),
-  z.array(WithStorageMetaZod(PayloadZod).loose()),
-])

package/src/block/index.ts

@@ -1,5 +0,0 @@
-export * from './AllowedBlockPayload.ts'
-export * from './BlockBoundWitness.ts'
-export * from './HydratedBlock.ts'
-export * from './signed/index.ts'
-export * from './unsigned/index.ts'

package/src/block/signed/SignedBlockBoundWitness.ts

@@ -1,22 +0,0 @@
-import {
-  zodAsFactory, zodIsFactory, zodToFactory,
-} from '@xylabs/sdk-js'
-import { SignedBoundWitnessZod } from '@xyo-network/sdk-js'
-import type { z } from 'zod'
-
-import { BlockBoundWitnessFieldsZod, BlockBoundWitnessMetaZod } from '../BlockBoundWitness.ts'
-
-/** SignedBlockBoundWitnessZod constant. */
-export const SignedBlockBoundWitnessZod = SignedBoundWitnessZod
-  .safeExtend(BlockBoundWitnessFieldsZod.shape)
-  .safeExtend(BlockBoundWitnessMetaZod.shape)
-
-/** SignedBlockBoundWitness type. */
-export type SignedBlockBoundWitness = z.infer<typeof SignedBlockBoundWitnessZod>
-
-/** Type guard that checks if a value is a valid SignedBlockBoundWitness. */
-export const isSignedBlockBoundWitness = zodIsFactory(SignedBlockBoundWitnessZod)
-/** Converts a value to SignedBlockBoundWitness, throwing if invalid. */
-export const asSignedBlockBoundWitness = zodAsFactory(SignedBlockBoundWitnessZod, 'asSignedBlockBoundWitness')
-/** toSignedBlockBoundWitness constant. */
-export const toSignedBlockBoundWitness = zodToFactory(SignedBlockBoundWitnessZod, 'toSignedBlockBoundWitness')

package/src/block/signed/SignedBlockBoundWitnessWithHashMeta.ts

@@ -1,35 +0,0 @@
-import {
-  zodAsFactory, zodIsFactory, zodToFactory,
-} from '@xylabs/sdk-js'
-import { PayloadBuilder, WithHashMetaZod } from '@xyo-network/sdk-js'
-import type { z } from 'zod'
-
-import { isSignedBlockBoundWitness, SignedBlockBoundWitnessZod } from './SignedBlockBoundWitness.ts'
-
-/** SignedBlockBoundWitnessWithHashMetaZod constant. */
-export const SignedBlockBoundWitnessWithHashMetaZod = WithHashMetaZod(SignedBlockBoundWitnessZod)
-
-/** SignedBlockBoundWitnessWithHashMeta type. */
-export type SignedBlockBoundWitnessWithHashMeta = z.infer<typeof SignedBlockBoundWitnessWithHashMetaZod>
-
-/** Type guard that checks if a value is a valid SignedBlockBoundWitnessWithHashMeta. */
-export const isSignedBlockBoundWitnessWithHashMeta = zodIsFactory(SignedBlockBoundWitnessWithHashMetaZod)
-/** Converts a value to SignedBlockBoundWitnessWithHashMeta, throwing if invalid. */
-export const asSignedBlockBoundWitnessWithHashMeta = zodAsFactory(SignedBlockBoundWitnessWithHashMetaZod, 'asSignedBlockBoundWitnessWithHashMeta')
-
-/** SignedBlockBoundWitnessWithHashMetaishZod constant. */
-export const SignedBlockBoundWitnessWithHashMetaishZod = SignedBlockBoundWitnessZod.transform(async (data) => {
-  if (isSignedBlockBoundWitnessWithHashMeta(data)) {
-    return data
-  }
-  if (isSignedBlockBoundWitness(data)) {
-    return await PayloadBuilder.addHashMeta(data)
-  }
-  throw new Error('Invalid SignedBlockBoundWitnessWithHashMetaish format')
-})
-
-/** SignedBlockBoundWitnessWithHashMetaish type. */
-export type SignedBlockBoundWitnessWithHashMetaish = z.input<typeof SignedBlockBoundWitnessWithHashMetaishZod>
-
-/** toSignedBlockBoundWitnessWithHashMeta constant. */
-export const toSignedBlockBoundWitnessWithHashMeta = zodToFactory(SignedBlockBoundWitnessWithHashMetaZod, 'toSignedBlockBoundWitnessWithHashMeta')

package/src/block/signed/SignedBlockBoundWitnessWithStorageMeta.ts

@@ -1,41 +0,0 @@
-import {
-  zodAsFactory, zodIsFactory, zodToFactory,
-} from '@xylabs/sdk-js'
-import { PayloadBuilder, WithStorageMetaZod } from '@xyo-network/sdk-js'
-import type { z } from 'zod'
-
-import { isSignedBlockBoundWitness, SignedBlockBoundWitnessZod } from './SignedBlockBoundWitness.ts'
-
-/** SignedBlockBoundWitnessWithStorageMetaZod constant. */
-export const SignedBlockBoundWitnessWithStorageMetaZod = WithStorageMetaZod(SignedBlockBoundWitnessZod)
-
-/** SignedBlockBoundWitnessWithStorageMeta type. */
-export type SignedBlockBoundWitnessWithStorageMeta = z.infer<typeof SignedBlockBoundWitnessWithStorageMetaZod>
-
-/** Type guard that checks if a value is a valid SignedBlockBoundWitnessWithStorageMeta. */
-export const isSignedBlockBoundWitnessWithStorageMeta = zodIsFactory(SignedBlockBoundWitnessWithStorageMetaZod)
-/** Converts a value to SignedBlockBoundWitnessWithStorageMeta, throwing if invalid. */
-export const asSignedBlockBoundWitnessWithStorageMeta = zodAsFactory(
-  SignedBlockBoundWitnessWithStorageMetaZod,
-  'asSignedBlockBoundWitnessWithStorageMeta',
-)
-
-/** SignedBlockBoundWitnessWithStorageMetaishZod constant. */
-export const SignedBlockBoundWitnessWithStorageMetaishZod = SignedBlockBoundWitnessZod.transform(async (data) => {
-  if (isSignedBlockBoundWitnessWithStorageMeta(data)) {
-    return data
-  }
-  if (isSignedBlockBoundWitness(data)) {
-    return await PayloadBuilder.addStorageMeta(data)
-  }
-  throw new Error('Invalid SignedBlockBoundWitnessWithStorageMetaish format')
-})
-
-/** SignedBlockBoundWitnessWithStorageMetaish type. */
-export type SignedBlockBoundWitnessWithStorageMetaish = z.input<typeof SignedBlockBoundWitnessWithStorageMetaishZod>
-
-/** toSignedBlockBoundWitnessWithStorageMeta constant. */
-export const toSignedBlockBoundWitnessWithStorageMeta = zodToFactory(
-  SignedBlockBoundWitnessWithStorageMetaishZod,
-  'toSignedBlockBoundWitnessWithStorageMeta',
-)

package/src/block/signed/index.ts

@@ -1,3 +0,0 @@
-export * from './SignedBlockBoundWitness.ts'
-export * from './SignedBlockBoundWitnessWithHashMeta.ts'
-export * from './SignedBlockBoundWitnessWithStorageMeta.ts'

package/src/block/unsigned/UnsignedBlockBoundWitness.ts

@@ -1,22 +0,0 @@
-import {
-  zodAsFactory, zodIsFactory, zodToFactory,
-} from '@xylabs/sdk-js'
-import { UnsignedBoundWitnessZod } from '@xyo-network/sdk-js'
-import type { z } from 'zod'
-
-import { BlockBoundWitnessFieldsZod, BlockBoundWitnessMetaZod } from '../BlockBoundWitness.ts'
-
-/** UnsignedBlockBoundWitnessZod constant. */
-export const UnsignedBlockBoundWitnessZod = UnsignedBoundWitnessZod
-  .safeExtend(BlockBoundWitnessFieldsZod.shape)
-  .safeExtend(BlockBoundWitnessMetaZod.shape)
-
-/** UnsignedBlockBoundWitness type. */
-export type UnsignedBlockBoundWitness = z.infer<typeof UnsignedBlockBoundWitnessZod>
-
-/** Type guard that checks if a value is a valid UnsignedBlockBoundWitness. */
-export const isUnsignedBlockBoundWitness = zodIsFactory(UnsignedBlockBoundWitnessZod)
-/** Converts a value to UnsignedBlockBoundWitness, throwing if invalid. */
-export const asUnsignedBlockBoundWitness = zodAsFactory(UnsignedBlockBoundWitnessZod, 'asUnsignedBlockBoundWitness')
-/** toUnsignedBlockBoundWitness constant. */
-export const toUnsignedBlockBoundWitness = zodToFactory(UnsignedBlockBoundWitnessZod, 'toUnsignedBlockBoundWitness')

package/src/block/unsigned/index.ts

@@ -1 +0,0 @@
-export * from './UnsignedBlockBoundWitness.ts'

package/src/chain/Chain.ts

@@ -1,7 +0,0 @@
-import { AddressRegEx, toAddress } from '@xylabs/sdk-js'
-import { z } from 'zod'
-
-import type { ChainId } from './ChainId.ts'
-
-/** ChainZod constant. */
-export const ChainZod = z.string().toLowerCase().regex(AddressRegEx).transform<ChainId>(v => toAddress(v) as ChainId)

package/src/chain/ChainAnalyzer.ts

@@ -1,11 +0,0 @@
-import type { Promisable } from '@xylabs/sdk-js'
-import type { Payload } from '@xyo-network/sdk-js'
-
-import type { HydratedBlock } from '../block/index.ts'
-
-/** ChainAnalyzer interface. */
-export interface ChainAnalyzer<T extends Payload = Payload> {
-  onBlock(block: HydratedBlock): Promisable<boolean>
-  result(): T
-  shouldContinue(): boolean
-}

package/src/chain/ChainId.ts

@@ -1,4 +0,0 @@
-import type { Hex } from '@xylabs/sdk-js'
-
-/** ChainId type. */
-export type ChainId = Hex

package/src/chain/index.ts

@@ -1,3 +0,0 @@
-export * from './Chain.ts'
-export * from './ChainAnalyzer.ts'
-export * from './ChainId.ts'

package/src/fields/Addressable.ts

@@ -1,7 +0,0 @@
-import type { Address } from '@xylabs/sdk-js'
-
-// NOTE: Minimal interface in case of reuse across validators, producers, wallets, modules, etc.
-/** Addressable interface. */
-export interface Addressable {
-  address: Address
-}

package/src/fields/BlockDuration.ts

@@ -1,25 +0,0 @@
-/** BlockStart interface. */
-export interface BlockStart {
-  /**
-   * The block at which the duration starts
-   */
-  nbf: number
-}
-
-/** BlockEnd interface. */
-export interface BlockEnd {
-  /**
-   * The block at which the duration ends
-   */
-  exp: number
-}
-
-/**
- * A optional duration referenced to block numbers
- */
-export interface OptionalBlockDuration extends Partial<BlockStart>, Partial<BlockEnd> {}
-
-/**
- * A duration referenced to block numbers
- */
-export interface BlockDuration extends BlockStart, BlockEnd {}

package/src/fields/BlockNumber.ts

@@ -1,40 +0,0 @@
-import { AsObjectFactory } from '@xylabs/sdk-js'
-import type { Payload, WithSources } from '@xyo-network/sdk-js'
-import {
-  asSchema,
-  isPayloadOfSchemaType,
-  isPayloadOfSchemaTypeWithSources,
-} from '@xyo-network/sdk-js'
-
-import type { XL1BlockNumber } from '../BlockNumber/index.ts'
-
-/** Schema identifier for BlockNumber payloads. */
-export const BlockNumberSchema = asSchema('network.xyo.chain.block.number', true)
-/** Schema type for BlockNumber payloads. */
-export type BlockNumberSchema = typeof BlockNumberSchema
-
-/** BlockNumberFields interface. */
-export interface BlockNumberFields {
-  /**
-   * The block number
-   */
-  block: XL1BlockNumber
-}
-/**
- * The number of a block
- */
-export type BlockNumberPayload = Payload<BlockNumberFields, BlockNumberSchema>
-
-/**
- * Identity function for determining if an object is a BlockNumber
- */
-export const isBlockNumberPayload = isPayloadOfSchemaType<BlockNumberPayload>(BlockNumberSchema)
-/** Converts a value to BlockNumberPayload, throwing if invalid. */
-export const asBlockNumberPayload = AsObjectFactory.create<BlockNumberPayload>(isBlockNumberPayload)
-
-/**
- * Identity function for determining if an object is a BlockNumber with sources
- */
-export const isBlockNumberPayloadWithSources = isPayloadOfSchemaTypeWithSources<BlockNumberPayload>(BlockNumberSchema)
-/** Converts a value to BlockNumberPayloadWithSources, throwing if invalid. */
-export const asBlockNumberPayloadWithSources = AsObjectFactory.create<WithSources<BlockNumberPayload>>(isBlockNumberPayloadWithSources)

package/src/fields/ChainReference.ts

@@ -1,11 +0,0 @@
-import type { ChainId } from '../chain/index.ts'
-
-/**
- * Required info for a chain reference
- */
-export interface ChainReference {
-  /**
-   * The contract address referenced by the chain
-   */
-  chain: ChainId
-}

package/src/fields/index.ts

@@ -1,4 +0,0 @@
-export * from './Addressable.ts'
-export * from './BlockDuration.ts'
-export * from './BlockNumber.ts'
-export * from './ChainReference.ts'

package/src/map/AsyncMap.ts

@@ -1,38 +0,0 @@
-import type { Promisable } from '@xylabs/sdk-js'
-
-/** AsyncMapRead interface. */
-export interface AsyncMapRead<K, V> {
-  get(id: K): Promisable<V | undefined>
-  getMany(id: K[]): Promisable<V[]>
-  has(id: K): Promisable<boolean>
-}
-/**
- * @deprecated Use AsyncMapRead instead
- */
-export interface AsynchronousMapRead<K, V> extends AsyncMapRead<K, V> {}
-
-/** AsyncMapWrite interface. */
-export interface AsyncMapWrite<K, V> {
-  clear(): Promisable<void>
-  delete(id: K): Promisable<boolean>
-  set(id: K, data: V): Promisable<K | undefined | void>
-  setMany(entries: [K, V][]): Promisable<K[] | void>
-}
-/**
- * @deprecated Use AsyncMapWrite instead
- */
-export interface AsynchronousMapWrite<K, V> extends AsyncMapWrite<K, V> {}
-
-/** AsyncMap interface. */
-export interface AsyncMap<K, V> extends AsyncMapRead<K, V>, AsyncMapWrite<K, V> {}
-/**
- * @deprecated Use AsyncMap instead
- */
-export interface AsynchronousMap<K, V> extends AsyncMap<K, V> {}
-
-/** AsyncIterableMapRead interface. */
-export interface AsyncIterableMapRead<K, V>extends AsyncMapRead<K, V>, AsyncIterable<[K, V]> {}
-/** AsyncIterableMapWrite interface. */
-export interface AsyncIterableMapWrite<K, V>extends AsyncMapWrite<K, V>, AsyncIterable<[K, V]> {}
-/** AsyncIterableMap interface. */
-export interface AsyncIterableMap<K, V>extends AsyncMap<K, V>, AsyncIterable<[K, V]> {}

package/src/map/MapType.ts

@@ -1,27 +0,0 @@
-import type {
-  AsyncIterableMap, AsyncIterableMapRead, AsyncIterableMapWrite, AsyncMap, AsyncMapRead, AsyncMapWrite,
-} from './AsyncMap.ts'
-import type {
-  SyncIterableMap, SyncIterableMapRead, SyncIterableMapWrite, SyncMap, SyncMapRead, SyncMapWrite,
-} from './SyncMap.ts'
-
-/** MapType type. */
-export type MapType<TId, TData> = SyncMap<TId, TData> | AsyncMap<TId, TData>
-
-/** MapTypeRead type. */
-export type MapTypeRead<TId, TData> = SyncMapRead<TId, TData> | AsyncMapRead<TId, TData>
-
-/** MapTypeWrite type. */
-export type MapTypeWrite<TId, TData> = SyncMapWrite<TId, TData> | AsyncMapWrite<TId, TData>
-
-/** AsynchronousMapType type. */
-export type AsynchronousMapType<TId, TData> = AsyncMapRead<TId, TData> & AsyncMapWrite<TId, TData>
-
-/** IterableMapRead type. */
-export type IterableMapRead<TId, TData> = SyncIterableMapRead<TId, TData> | AsyncIterableMapRead<TId, TData>
-
-/** IterableMapWrite type. */
-export type IterableMapWrite<TId, TData> = SyncIterableMapWrite<TId, TData> | AsyncIterableMapWrite<TId, TData>
-
-/** IterableMap type. */
-export type IterableMap<TId, TData> = SyncIterableMap<TId, TData> | AsyncIterableMap<TId, TData>

package/src/map/SyncMap.ts

@@ -1,38 +0,0 @@
-/** SyncMapRead interface. */
-export interface SyncMapRead<K, V> {
-  get(id: K): V | undefined
-  getMany(id: K[]): V[]
-  has(id: K): boolean
-}
-
-/**
- * @deprecated Use SyncMapRead instead
- */
-export interface SynchronousMapRead<K, V> extends SyncMapRead<K, V> {}
-
-/** SyncMapWrite interface. */
-export interface SyncMapWrite<K, V> {
-  clear(): void
-  delete(id: K): boolean
-  set(id: K, data: V): K | undefined | void
-  setMany(entries: [K, V][]): K[] | void
-}
-
-/**
- * @deprecated Use SyncMapWrite instead
- */
-export interface SynchronousMapWrite<K, V> extends SyncMapWrite<K, V> {}
-
-/** SyncMap interface. */
-export interface SyncMap<K, V> extends SyncMapRead<K, V>, SyncMapWrite<K, V> {}
-/**
- * @deprecated Use SyncMap instead
- */
-export interface SynchronousMap<K, V> extends SyncMap<K, V> {}
-
-/** SyncIterableMapRead interface. */
-export interface SyncIterableMapRead<K, V> extends SyncMapRead<K, V>, Iterable<[K, V]> {}
-/** SyncIterableMapWrite interface. */
-export interface SyncIterableMapWrite<K, V> extends SyncMapWrite<K, V>, Iterable<[K, V]> {}
-/** SyncIterableMap interface. */
-export interface SyncIterableMap<K, V> extends SyncMap<K, V>, Iterable<[K, V]> {}

package/src/map/index.ts

@@ -1,3 +0,0 @@
-export * from './AsyncMap.ts'
-export * from './MapType.ts'
-export * from './SyncMap.ts'

package/src/model/AccountBalance.ts

@@ -1,58 +0,0 @@
-import { type Address, type Promisable } from '@xylabs/sdk-js'
-import { zodIsFactory } from '@xylabs/sdk-js'
-import { WithHashMetaZod } from '@xyo-network/sdk-js'
-import { z } from 'zod'
-
-import { BlockBoundWitnessZod } from '../block/index.ts'
-import type { Provider } from '../provider/index.ts'
-import { TransactionBoundWitnessZod } from '../transaction/index.ts'
-import { TransferZod } from '../TransferPayload.ts'
-import type { AttoXL1 } from '../xl1/index.ts'
-import type { ChainQualified } from './ChainQualification.ts'
-import { ChainQualificationZod, ChainQualifiedConfigZod } from './ChainQualification.ts'
-
-/** AccountBalanceHistoryItemZod constant. */
-export const AccountBalanceHistoryItemZod = z.tuple([
-  WithHashMetaZod(BlockBoundWitnessZod),
-  WithHashMetaZod(TransactionBoundWitnessZod).nullable(),
-  WithHashMetaZod(TransferZod),
-])
-
-/** AccountBalanceHistoryItem type. */
-export type AccountBalanceHistoryItem = z.infer<typeof AccountBalanceHistoryItemZod>
-
-/** AccountBalanceQualificationZod constant. */
-export const AccountBalanceQualificationZod = ChainQualificationZod
-/** AccountBalanceQualification type. */
-export type AccountBalanceQualification = z.infer<typeof AccountBalanceQualificationZod>
-/** Type guard that checks if a value is a valid AccountBalanceQualification. */
-export const isAccountBalanceQualification = zodIsFactory(AccountBalanceQualificationZod)
-
-/** AccountBalanceConfigZod constant. */
-export const AccountBalanceConfigZod = ChainQualifiedConfigZod
-/** AccountBalanceConfig type. */
-export type AccountBalanceConfig = z.infer<typeof AccountBalanceConfigZod>
-/** Type guard that checks if a value is a valid AccountBalanceConfig. */
-export const isAccountBalanceConfig = zodIsFactory(AccountBalanceConfigZod)
-
-/** AccountBalanceViewerMethods interface. */
-export interface AccountBalanceViewerMethods {
-  qualifiedAccountBalanceHistories(
-    address: Address[],
-    config: AccountBalanceConfig
-  ): Promisable<ChainQualified<Record<Address, AccountBalanceHistoryItem[]>>>
-  qualifiedAccountBalances(address: Address[], config: AccountBalanceConfig): Promisable<ChainQualified<Record<Address, AttoXL1>>>
-}
-
-/** Viewer interface for reading AccountBalance data. */
-export interface AccountBalanceViewer extends AccountBalanceViewerMethods, Provider<AccountBalanceViewerMoniker> {
-  accountBalance(address: Address, config?: AccountBalanceConfig): Promisable<AttoXL1>
-  accountBalanceHistories(address: Address[], config?: AccountBalanceConfig): Promisable<Record<Address, AccountBalanceHistoryItem[]>>
-  accountBalanceHistory(address: Address, config?: AccountBalanceConfig): Promisable<AccountBalanceHistoryItem[]>
-  accountBalances(address: Address[], config?: AccountBalanceConfig): Promisable<Record<Address, AttoXL1>>
-}
-
-/** Moniker identifier for the AccountBalanceViewer provider. */
-export const AccountBalanceViewerMoniker = 'AccountBalanceViewer' as const
-/** Type literal for the AccountBalanceViewer provider moniker. */
-export type AccountBalanceViewerMoniker = typeof AccountBalanceViewerMoniker

package/src/model/ArrayBuffer.ts

@@ -1,44 +0,0 @@
-import { z } from 'zod'
-
-function base64Encode(u8: Uint8Array): string {
-  // Node
-  if (typeof Buffer !== 'undefined' && typeof Buffer.from === 'function') {
-    return Buffer.from(u8).toString('base64')
-  }
-
-  // Browser
-  let binary = ''
-  const chunk = 0x80_00
-  for (let i = 0; i < u8.length; i += chunk) {
-    // eslint-disable-next-line unicorn/prefer-code-point
-    binary += String.fromCharCode(...u8.subarray(i, i + chunk))
-  }
-  return btoa(binary)
-}
-
-/** Base64 decode that works in Node and browsers -> Uint8Array */
-function base64Decode(b64: string): Uint8Array {
-  // Node
-  if (typeof Buffer !== 'undefined' && typeof Buffer.from === 'function') {
-    return new Uint8Array(Buffer.from(b64, 'base64'))
-  }
-
-  // Browser
-  const binary = atob(b64)
-  const u8 = new Uint8Array(binary.length)
-  // eslint-disable-next-line unicorn/prefer-code-point
-  for (let i = 0; i < binary.length; i++) u8[i] = binary.charCodeAt(i)
-  return u8
-}
-
-/** ArrayBufferToJsonZod constant. */
-export const ArrayBufferToJsonZod = z.instanceof(ArrayBuffer).transform((x) => {
-  const u8 = new Uint8Array(x)
-  return base64Encode(u8)
-})
-
-/** JsonToArrayBufferZod constant. */
-export const JsonToArrayBufferZod = z.string().transform((x) => {
-  const u8 = base64Decode(x)
-  return u8.buffer
-})