@xyo-network/xl1-protocol 1.6.2 → 1.6.3

package/dist/neutral/index.d.ts

@@ -0,0 +1,830 @@
+import { Payload, WithSources, WithStorageMeta, WithHashStorageMeta, Schema } from '@xyo-network/payload-model';
+import { SchemaPayload } from '@xyo-network/schema-payload-plugin';
+import { Address, Hex, Hash } from '@xylabs/hex';
+import { EmptyObject, JsonValue } from '@xylabs/object';
+import { BoundWitness, Signed } from '@xyo-network/boundwitness-model';
+import { Promisable } from '@xylabs/promise';
+import { MeterProvider, TracerProvider } from '@opentelemetry/api';
+import { NextOptions, ArchivistInstance, WriteArchivist, HydratedBoundWitness, HydratedBoundWitnessWithStorageMeta, ReadArchivist } from '@xyo-network/archivist-model';
+import { BaseParams } from '@xylabs/base';
+import { EventData, BaseEmitter } from '@xylabs/events';
+import { WalletInstance } from '@xyo-network/wallet-model';
+
+interface Addressable {
+    address: Address;
+}
+
+interface BlockStart {
+    /**
+     * The block at which the duration starts
+     */
+    nbf: number;
+}
+interface BlockEnd {
+    /**
+     * The block at which the duration ends
+     */
+    exp: number;
+}
+/**
+ * A optional duration referenced to block numbers
+ */
+interface OptionalBlockDuration extends Partial<BlockStart>, Partial<BlockEnd> {
+}
+/**
+ * A duration referenced to block numbers
+ */
+interface BlockDuration extends BlockStart, BlockEnd {
+}
+
+declare const BlockNumberSchema: "network.xyo.chain.block.number";
+type BlockNumberSchema = typeof BlockNumberSchema;
+interface BlockNumberFields {
+    /**
+     * The block number
+     */
+    block: Hex;
+}
+/**
+ * The number of a block
+ */
+type BlockNumber = Payload<BlockNumberFields, BlockNumberSchema>;
+/**
+ * Identity function for determining if an object is a BlockNumber
+ */
+declare const isBlockNumber: (x?: unknown | null) => x is BlockNumber;
+declare const asBlockNumber: _xylabs_object_model.AsTypeFunction<T>;
+/**
+ * Identity function for determining if an object is a BlockNumber with sources
+ */
+declare const isBlockNumberWithSources: (x?: unknown | null) => x is WithSources<BlockNumber>;
+declare const asBlockNumberWithSources: _xylabs_object_model.AsTypeFunction<T>;
+
+/**
+ * Required info for a chain reference
+ */
+interface ChainReference {
+    /**
+     * The contract address referenced by the chain
+     */
+    chain: Address;
+}
+
+interface FromFields {
+    from: Address;
+}
+declare const hasFrom: (value: unknown) => value is FromFields;
+interface ExecutableFields {
+    script: string[];
+}
+type Executable<T extends EmptyObject = EmptyObject> = T & ExecutableFields;
+type OptionalExecutable<T extends EmptyObject = EmptyObject> = T & Partial<ExecutableFields>;
+declare const isExecutable: <T extends EmptyObject>(value: T | undefined) => value is Executable<T>;
+declare const asExecutable: <T extends EmptyObject>(value: T | undefined) => Executable<T> | undefined;
+
+declare const ChainStakeIntentSchema: "network.xyo.chain.stake.intent";
+type ChainStakeIntentSchema = typeof ChainStakeIntentSchema;
+type Intent = 'producer';
+interface ChainStakeIntentFields extends BlockDuration, FromFields {
+    intent: Intent;
+}
+type ChainStakeIntent = Payload<ChainStakeIntentFields, ChainStakeIntentSchema>;
+declare const isChainStakeIntent: (x?: unknown | null) => x is ChainStakeIntent;
+declare const asChainStakeIntent: _xylabs_object_model.AsTypeFunction<T>;
+declare const isChainStakeIntentWithStorageMeta: (x?: unknown | null) => x is WithStorageMeta<ChainStakeIntent>;
+
+declare const HashSchema: "network.xyo.hash";
+type HashSchema = typeof HashSchema;
+interface HashFields {
+    hash: Hash;
+}
+type HashPayload = Payload<HashFields, HashSchema>;
+declare const isHashPayload: (x?: unknown | null) => x is HashPayload;
+declare const asHashPayload: _xylabs_object_model.AsTypeFunction<T>;
+declare const asHashPayloadWithStorageMeta: _xylabs_object_model.AsTypeFunction<T>;
+
+declare const TransferSchema: "network.xyo.transfer";
+type TransferSchema = typeof TransferSchema;
+interface TransferFields extends FromFields {
+    epoch: number;
+    transfers: Partial<Record<Address, Hex>>;
+}
+type Transfer = Payload<TransferFields, TransferSchema>;
+declare const isTransfer: (x?: unknown | null) => x is Transfer;
+declare const asTransfer: _xylabs_object_model.AsTypeFunction<T>;
+
+type TypingFunc<T extends bigint> = (value: bigint) => T;
+type XL1 = bigint & {
+    readonly _tag: 'XL1';
+};
+declare const XL1: TypingFunc<XL1>;
+type MilliXL1 = bigint & {
+    readonly _tag: 'MilliXL1';
+};
+declare const MilliXL1: TypingFunc<MilliXL1>;
+type MicroXL1 = bigint & {
+    readonly _tag: 'MicroXL1';
+};
+declare const MicroXL1: TypingFunc<MicroXL1>;
+type NanoXL1 = bigint & {
+    readonly _tag: 'NanoXL1';
+};
+declare const NanoXL1: TypingFunc<NanoXL1>;
+type PicoXL1 = bigint & {
+    readonly _tag: 'PicoXL1';
+};
+declare const PicoXL1: TypingFunc<PicoXL1>;
+type FemtoXL1 = bigint & {
+    readonly _tag: 'FemtoXL1';
+};
+declare const FemtoXL1: TypingFunc<FemtoXL1>;
+type AttoXL1 = bigint & {
+    readonly _tag: 'AttoXL1';
+};
+declare const AttoXL1: TypingFunc<AttoXL1>;
+type XL1Units = 'xl1' | 'milli' | 'micro' | 'nano' | 'pico' | 'femto' | 'atto';
+/** @deprecated use XL1Places and xl1ConvertFactor(unit) instead */
+declare const XL1ConvertDict: Record<XL1Units, number>;
+declare const XL1Places: Record<XL1Units, bigint>;
+/**
+ * Convert factor by which a respective unit is multiplied to convert it to AttoXL1 or
+ * by which AttoXL1 is divided to convert it to respective unit is multiplied.
+ */
+declare const AttoXL1ConvertFactor: Record<XL1Units, bigint>;
+/** @deprecated use AttoXL1ConvertFactor instead */
+declare function xl1ConvertFactor(unit: XL1Units): bigint;
+
+interface TransactionFeesBigInt {
+    base: AttoXL1;
+    gasLimit: AttoXL1;
+    gasPrice: AttoXL1;
+    priority: AttoXL1;
+}
+type TransactionFeesHex = {
+    [K in keyof TransactionFeesBigInt]: Hex;
+};
+interface TransactionFeesFields {
+    fees: TransactionFeesHex;
+}
+
+interface TransactionBoundWitnessFields extends BlockDuration, TransactionFeesFields {
+    chain: Address;
+}
+type TransactionBoundWitness = BoundWitness<TransactionBoundWitnessFields & OptionalExecutable & FromFields>;
+declare const isTransactionBoundWitness: (value: unknown) => value is TransactionBoundWitness;
+declare const isSignedTransactionBoundWitness: (value: unknown) => value is Signed<TransactionBoundWitness>;
+declare const isSigned: <T extends BoundWitness = BoundWitness>(value: unknown) => value is Signed<T>;
+declare const isTransactionBoundWitnessWithStorageMeta: (value: unknown) => value is WithStorageMeta<TransactionBoundWitness>;
+declare const isTransactionBoundWitnessWithHashStorageMeta: (value: unknown) => value is WithHashStorageMeta<TransactionBoundWitness>;
+declare const isSignedTransactionBoundWitnessWithStorageMeta: (value: unknown) => value is WithStorageMeta<Signed<TransactionBoundWitness>>;
+declare const isSignedTransactionBoundWitnessWithHashStorageMeta: (value: unknown) => value is WithHashStorageMeta<Signed<TransactionBoundWitness>>;
+declare const asTransactionBoundWitness: _xylabs_object_model.AsTypeFunction<T>;
+declare const asTransactionBoundWitnessWithStorageMeta: _xylabs_object_model.AsTypeFunction<T>;
+declare const asTransactionBoundWitnessWithHashStorageMeta: _xylabs_object_model.AsTypeFunction<T>;
+
+type HydratedTransaction<T extends TransactionBoundWitness = TransactionBoundWitness, P extends Payload = Payload> = [WithStorageMeta<Signed<T>>, WithStorageMeta<P>[]];
+declare const isHydratedTransaction: (value: unknown) => value is HydratedTransaction;
+declare const asHydratedTransaction: _xylabs_object_model.AsTypeFunction<T>;
+
+type AllowedBlockPayload = Transfer | ChainStakeIntent | SchemaPayload | TransactionBoundWitness | HashPayload;
+declare const AllowedBlockPayloadSchemas: Schema[];
+type AllowedBlockPayloadSchema = typeof AllowedBlockPayloadSchemas[number];
+declare const isAllowedBlockPayloadSchema: (value: unknown) => value is AllowedBlockPayloadSchema;
+declare const isAllowedBlockPayload: (value: unknown) => value is AllowedBlockPayload;
+declare const isAllowedBlockPayloadWithHashStorageMeta: (value: unknown) => value is WithStorageMeta<AllowedBlockPayload>;
+
+interface BlockBoundWitnessMeta {
+    $epoch: number;
+}
+interface BlockBoundWitnessFields {
+    /** Block number */
+    block: number;
+    /** Chain id - this should be "0" for the genesis block */
+    chain: Hex;
+    /** Previous block hash if not block 0 */
+    previous: Hash | null;
+    /** Version of the protocol being used major * 1,000,000 + minor * 1,000 + patch */
+    protocol: number;
+    /** Step hashes */
+    step_hashes: Hex[];
+}
+type BlockBoundWitness = BoundWitness<BlockBoundWitnessFields & BlockBoundWitnessMeta>;
+declare const isBlockBoundWitness: (value: unknown) => value is BlockBoundWitness;
+declare const isSignedBlockBoundWitness: (value: unknown) => value is Signed<BlockBoundWitness>;
+declare const isBlockBoundWitnessWithStorageMeta: (value: unknown) => value is WithStorageMeta<BlockBoundWitness>;
+declare const isSignedBlockBoundWitnessWithStorageMeta: (value: unknown) => value is Signed<WithStorageMeta<BlockBoundWitness>>;
+declare const isBlockBoundWitnessWithHashStorageMeta: (value: unknown) => value is WithHashStorageMeta<BlockBoundWitness>;
+declare const isSignedBlockBoundWitnessWithHashStorageMeta: (value: unknown) => value is Signed<WithHashStorageMeta<BlockBoundWitness>>;
+declare const asBlockBoundWitness: _xylabs_object_model.AsTypeFunction<T>;
+declare const asSignedBlockBoundWitness: _xylabs_object_model.AsTypeFunction<T>;
+declare const asBlockBoundWitnessWithStorageMeta: _xylabs_object_model.AsTypeFunction<T>;
+declare const asSignedBlockBoundWitnessWithStorageMeta: _xylabs_object_model.AsTypeFunction<T>;
+declare const asBlockBoundWitnessWithHashStorageMeta: _xylabs_object_model.AsTypeFunction<T>;
+declare const asSignedBlockBoundWitnessWithHashStorageMeta: _xylabs_object_model.AsTypeFunction<T>;
+
+type HydratedBlock<T extends BlockBoundWitness = BlockBoundWitness, P extends Payload = Payload> = [WithStorageMeta<Signed<T>>, WithStorageMeta<P>[]];
+declare const isHydratedBlock: (value: unknown) => value is HydratedBlock;
+declare const asHydratedBlock: _xylabs_object_model.AsTypeFunction<T>;
+
+interface ChainAnalyzer<T extends Payload = Payload> {
+    onBlock(block: HydratedBlock): Promisable<boolean>;
+    result(): T;
+    shouldContinue(): boolean;
+}
+
+declare const defaultTransactionFees: TransactionFeesBigInt;
+
+declare const minTransactionFees: TransactionFeesBigInt;
+
+declare const StepSizes: readonly [7, 31, 211, 2311, 30031, 510511, 9699691, 223092871, 6469693231];
+declare function isValidStep(step: unknown): step is number;
+declare const asValidStep: AsTypeFunction<T>;
+declare function stepSize(step: number): number;
+
+declare const TransactionGasCosts: {
+    /**
+     * The cost of storing each character that is added to the chain
+     * This includes the transaction JSON and all the elevated payloads' JSON
+    */
+    readonly characterStorage: 10n;
+    /** The cost of static validating every payload that will be included in the chain */
+    readonly payloadValidation: 1000n;
+    /** The cost of validating each signature that will be included in the chain */
+    readonly signatureValidation: 1000n;
+    /** The cost of validating each hash that will be included in the chain */
+    readonly hashValidation: 100n;
+    /** The cost of validating a balance state, triggered by a Transfer payload or gas collection */
+    readonly balanceValidation: 100n;
+};
+
+declare const XL1_PROTOCOL_VERSION_MAJOR: 1;
+declare const XL1_PROTOCOL_VERSION_MINOR: 2;
+declare const XL1_PROTOCOL_VERSION_PATCH: 0;
+declare const XL1_PROTOCOL_VERSION_STRING: "1.2.0";
+declare const XL1_PROTOCOL_VERSION: number;
+
+type Initializable<T, R> = (params: T) => Promisable<R>;
+
+type DefaultNetworkIds = 'mainnet' | 'sequence' | 'local';
+type NetworkId<T extends string | void = void> = T extends void ? DefaultNetworkIds : T | DefaultNetworkIds;
+
+declare const NetworkStatusSchema: "network.xyo.chain.status";
+type NetworkStatusSchema = typeof NetworkStatusSchema;
+type NetworkStatusState = 'online' | 'offline' | 'degraded' | 'unknown';
+type NetworkStatusUpdate = {
+    end: number;
+    start: number;
+    update: string;
+};
+interface NetworkStatusFields {
+    description: string;
+    state: NetworkStatusState;
+    updates?: NetworkStatusUpdate[];
+}
+type NetworkStatus = Payload<NetworkStatusFields, NetworkStatusSchema>;
+declare const isNetworkStatus: (x?: unknown | null) => x is NetworkStatus;
+
+interface OpenTelemetryProviders {
+    meterProvider?: MeterProvider;
+    traceProvider?: TracerProvider;
+}
+
+interface XyoPayloadLakeViewer {
+    getPayloads(hashes: Hash[]): Promisable<Payload[]>;
+}
+interface XyoPayloadLakeProvider extends XyoPayloadLakeViewer {
+    addPayloads(payloads: Payload[]): Promisable<Hash[]>;
+}
+interface XyoDataLakeViewer extends XyoPayloadLakeViewer {
+    fetch(hashes: Hash[], maxDepth?: number): Promisable<(ArrayBuffer | Payload)[]>;
+    get(hashes: Hash[]): Promisable<(ArrayBuffer | Payload)[]>;
+    trace(hashes: Hash[]): Promisable<[(ArrayBuffer | Payload), Payload[]][]>;
+}
+interface XyoDataLakeProvider extends XyoDataLakeViewer, XyoPayloadLakeProvider {
+    add(items: ArrayBuffer[]): Promisable<Hash[]>;
+}
+
+interface ChainConnection {
+    /** Chain Identifier - can be a hex (eth contract address) or a string */
+    chainId?: string | Hex;
+    /** Name of the chain */
+    name: string;
+    /** Url for accessing the network */
+    url: string;
+}
+/**
+ * Modeled after EIP-2255
+ * See - https://eips.ethereum.org/EIPS/eip-2255#specification
+ */
+interface PermissionRequest {
+    [capability: string]: {
+        [caveatName: string]: JsonValue;
+    };
+}
+/**
+ * Modeled after EIP-2255
+ * See - https://eips.ethereum.org/EIPS/eip-2255#specification
+ */
+interface RequestedPermission {
+    /** Permission identifier (i.e. RPC method, action, etc.) */
+    capability: string;
+    /** Optional timestamp for when the permission was granted */
+    date?: number;
+}
+type CaveatTypes = 'chain' | 'expiration' | 'filteredResponse' | 'rateLimit';
+/**
+ * Modeled after EIP-2255
+ * See - https://eips.ethereum.org/EIPS/eip-2255#specification
+ */
+interface Caveats {
+    /** Type of caveat */
+    type: CaveatTypes;
+    /** Value for the caveat (i.e. chain id, subset of accounts, expiration, max request per minute, etc.) */
+    value: JsonValue;
+}
+/**
+ * Modeled after EIP-2255
+ * See - https://eips.ethereum.org/EIPS/eip-2255#specification
+ */
+interface Permission {
+    /** Permission identifier (i.e. RPC method, action, etc.) */
+    capability: string;
+    /** Caveats for the permission, if applicable (i.e. allowed accounts, signing, etc.) */
+    caveats?: Caveats[];
+    /** Invoker for the given permission (URI, domain, webpage, address, etc.) */
+    invoker: string;
+}
+interface InvokerPermission extends Permission {
+    /** Time at which the permission was granted */
+    date?: number;
+}
+interface XyoHost {
+    addChain(chainConnectionInfo: ChainConnection): Promisable<boolean>;
+    chains(): Promisable<ChainConnection[]>;
+    getPermissions(): Promisable<InvokerPermission[]>;
+    requestPermissions(permissions: Permission[]): Promisable<boolean>;
+    revokePermissions(permissions: Permission[]): Promisable<boolean>;
+}
+
+interface XyoNetwork {
+    status(): Promisable<NetworkStatus>;
+}
+
+interface XyoRunner {
+    broadcastTransaction(transaction: HydratedTransaction): Promisable<Hash>;
+}
+
+interface XyoSigner {
+    address(): Promisable<Address>;
+    createSignedTransaction(chain: Address, elevatedPayloads: AllowedBlockPayload[], additionalPayloads: Payload[], nbf: number, exp: number, fees: TransactionFeesBigInt, from?: Address): Promisable<Signed<TransactionBoundWitness>>;
+}
+
+interface XyoViewer {
+    accountBalance: (address: Address) => Promisable<bigint>;
+    accountHistory: (address: Address) => Promisable<[TransactionBoundWitness[], Transfer[]]>;
+    blockByHash(hash: Hash): Promisable<HydratedBlock | null>;
+    blockByNumber(blockNumber: number): Promisable<HydratedBlock | null>;
+    blocksByHash(hash: Hash, limit?: number): Promisable<HydratedBlock[]>;
+    chainId(): Promisable<Address>;
+    currentBlock(): Promisable<HydratedBlock>;
+    currentBlockHash(): Promisable<Hash>;
+    currentBlockNumber(): Promisable<number>;
+    transactionByBlockHashAndIndex(blockHash: Hash, transactionIndex: number): Promisable<HydratedTransaction | null>;
+    transactionByBlockNumberAndIndex(blockNumber: number, transactionIndex: number): Promisable<HydratedTransaction | null>;
+    transactionByHash(transactionHash: Hash): Promisable<HydratedTransaction | null>;
+}
+
+/** @deprecated  - use XyoHost instead */
+interface XyoWallet {
+    accounts(): Promisable<Address[]>;
+    addChain(chain: Address, name?: string): Promisable<object>;
+    chain(): Promisable<Address>;
+    chains(): Promisable<object>;
+    permissions(): Promisable<Record<string, object>>;
+    requestPermissions(permissions: object): Promisable<object>;
+    revokePermissions(permissions: object): Promisable<object>;
+    switchChain(chain: Address): Promisable<void>;
+}
+
+interface XyoProvider {
+    host?: XyoHost;
+    network?: XyoNetwork;
+    runner?: XyoRunner;
+    send?: (elevatedPayloads: AllowedBlockPayload[], additionalPayloads: Payload[], chain?: Address, nbf?: number, exp?: number, from?: Address, fees?: TransactionFeesBigInt) => Promise<Signed<TransactionBoundWitness>>;
+    signer?: XyoSigner;
+    storage?: XyoDataLakeProvider;
+    viewer?: XyoViewer;
+    /** @deprecated  - use host instead */
+    wallet?: XyoWallet;
+}
+
+interface ReadRepository<TId, TData> {
+    get(id: TId): Promisable<TData>;
+}
+interface IterableRepository<TId, TData> {
+    next(id: TId): Promisable<TData>;
+}
+interface WriteRepository<TData, TResp> {
+    insert(data: TData): Promisable<TResp>;
+}
+interface PayloadReadRepository<TId = Hash, TData extends Payload = Payload> extends ReadRepository<TId[], WithStorageMeta<TData>[]> {
+}
+interface PayloadWriteRepository<TData extends Payload = Payload> extends WriteRepository<TData[], WithStorageMeta<TData>[]> {
+}
+interface PayloadIterableRepository<TId = Hash, TData extends Payload = Payload> extends IterableRepository<NextOptions<TId>, WithStorageMeta<TData>[]> {
+}
+interface PayloadRepository<TId = Hash, TData extends Payload = Payload> extends PayloadReadRepository<TId, TData>, PayloadWriteRepository<TData>, PayloadIterableRepository<TId, TData> {
+}
+
+interface TransactionReadRepository extends ReadRepository<TransactionBoundWitness, HydratedTransaction | undefined> {
+}
+
+interface TransactionRepositoryIterator extends IterableRepository<TransactionBoundWitness, HydratedTransaction | undefined> {
+}
+
+interface TransactionWriteRepository extends WriteRepository<HydratedTransaction, boolean> {
+}
+
+interface TransactionRepository extends TransactionReadRepository, TransactionWriteRepository {
+}
+interface ReadonlyIterableTransactionRepository extends TransactionReadRepository, TransactionRepositoryIterator {
+}
+interface IterableTransactionRepository extends TransactionRepository, TransactionRepositoryIterator {
+}
+
+interface Service {
+}
+
+interface AccountBalanceService extends Service {
+    getBalanceValue?: (address: Address) => bigint;
+    getBalanceValues?: Record<Address, bigint>;
+    getBalance(address: Address): Hex;
+    getBalances(): Record<Address, Hex>;
+    sync(head: Hash): Promise<void>;
+}
+interface AccountBalanceServiceV2 extends Service {
+    balances(head: Hash, addresses: Address[]): Promisable<Partial<Record<Address, AttoXL1>>>;
+}
+
+type NextBlockProducer = IterableRepository<BlockBoundWitness, HydratedBlock | undefined>;
+interface BlockProducerService extends Addressable, NextBlockProducer, Service {
+}
+
+interface BlockRewardService extends Service {
+    getRewardForBlock(block: bigint): Promisable<bigint>;
+}
+
+interface BaseChainService extends Service {
+    chainId: Address;
+}
+
+interface ChainHeadService extends BaseChainService {
+    head: Hash | null;
+}
+
+interface ChainContractViewer {
+    active(): Promise<bigint>;
+    forkedAtBlockNumber(): Promise<bigint>;
+    forkedAtHash(): Promise<bigint>;
+    forkedChainId(): Promise<Address>;
+    minWithdrawalBlocks(): Promise<bigint>;
+    rewardsContract(): Promise<string>;
+    stakingTokenAddress(): Promise<string>;
+}
+
+interface ChainStaker {
+    addStake(staked: string, amount: bigint): Promise<boolean>;
+    removeStake(slot: bigint): Promise<boolean>;
+    withdrawStake(slot: bigint): Promise<boolean>;
+}
+
+interface ChainStakeViewer extends ChainContractViewer {
+    activeByAddressStaked(address: string): Promise<bigint>;
+    activeByStaker(address: string): Promise<bigint>;
+    pending(): Promise<bigint>;
+    pendingByStaker(staker: string): Promise<bigint>;
+    withdrawn(): Promise<bigint>;
+    withdrawnByStaker(staker: string): Promise<bigint>;
+}
+
+interface ChainService extends ChainContractViewer, ChainStakeViewer, ChainStaker, BaseChainService {
+}
+
+type HeadEventArgs = {
+    blocks: [BlockBoundWitness];
+};
+interface HeadEventData extends EventData {
+    headUpdated: HeadEventArgs;
+}
+interface ChainIteratorServiceEventData extends HeadEventData {
+}
+/** @deprecated use ChainIteratorServiceEventData instead */
+interface ChainIteratorEventData extends ChainIteratorServiceEventData {
+}
+
+interface ChainIteratorService<TKey, THead> extends ReadRepository<TKey, BlockBoundWitness | undefined>, IterableRepository<TKey, BlockBoundWitness | undefined> {
+    chainId: Address;
+    head(): Promise<THead>;
+    previous(cursor?: TKey | undefined, limit?: number): Promise<BlockBoundWitness[]>;
+    updateHead(head: THead): Promise<void>;
+}
+/** @deprecated use ChainIteratorService instead */
+interface ChainIterator<TKey, THead> extends ChainIteratorService<TKey, THead> {
+}
+interface EventingChainIteratorService<TKey, THead> extends ChainIteratorService<TKey, THead>, BaseEmitter<BaseParams, ChainIteratorServiceEventData> {
+}
+/** @deprecated use EventingChainIteratorService instead */
+interface EventingChainIterator<TKey, THead> extends EventingChainIteratorService<TKey, THead> {
+}
+interface ChainBlockNumberIteratorService extends ChainIteratorService<number, BlockBoundWitness> {
+}
+/** @deprecated use ChainBlockNumberIteratorService instead */
+interface ChainBlockNumberIterator extends ChainBlockNumberIteratorService {
+}
+interface EventingChainBlockNumberIteratorService extends EventingChainIteratorService<number, BlockBoundWitness> {
+}
+/** @deprecated use EventingChainBlockNumberIteratorService instead */
+interface EventingChainBlockNumberIterator extends EventingChainBlockNumberIteratorService {
+}
+interface ChainHashIteratorService extends ChainIteratorService<Hash, Hash> {
+}
+/** @deprecated use ChainHashIteratorService instead */
+interface ChainHashIterator extends ChainHashIteratorService {
+}
+interface EventingChainHashIteratorService extends EventingChainIteratorService<Hash, Hash> {
+}
+/** @deprecated use EventingChainHashIteratorService instead */
+interface EventingChainHashIterator extends EventingChainHashIteratorService {
+}
+
+interface ElectionService extends Service {
+    /**
+     * Given the current block, get the leader for the next block
+     * @param current The previous block
+     */
+    getCreatorCommitteeForNextBlock(current: BlockBoundWitness): Promise<Address[]>;
+}
+
+interface ChainIndexingServiceStateFields<T extends JsonValue = JsonValue> {
+    /**
+     * The hash of the last block that this service has indexing
+     */
+    endBlockHash: Hash;
+    /**
+     * The hash of the block that the service started indexing. If undefined, the service is
+     * assumed to have started indexing from the genesis block
+     */
+    startBlockHash?: Hash;
+    /**
+     * The indexed state for the range
+     */
+    state: T;
+}
+declare const ChainIndexingServiceStateSchema: "network.xyo.chain.indexing.service.state";
+type ChainIndexingServiceStateSchema = typeof ChainIndexingServiceStateSchema;
+/**
+ * The result of a ChainIndexingServiceState
+ */
+type ChainIndexingServiceState<T extends JsonValue = JsonValue> = Payload<ChainIndexingServiceStateFields<T>, ChainIndexingServiceStateSchema>;
+/**
+ * Identity functions for determining if an object is an ChainIndexingServiceState
+ */
+declare const isChainIndexingServiceState: <T extends JsonValue = JsonValue>(payload?: unknown) => payload is ChainIndexingServiceState<T>;
+declare const asChainIndexingServiceState: _xylabs_object_model.AsTypeFunction<T>;
+declare const isChainIndexingServiceStateWithStorageMeta: <T extends JsonValue = JsonValue>(value: unknown) => value is WithStorageMeta<ChainIndexingServiceState<T>>;
+declare const asChainIndexingServiceStateWithStorageMeta: _xylabs_object_model.AsTypeFunction<T>;
+
+interface StakeIntentService extends Service {
+    /**
+     * Gets the declared ranges for an address based on historical on-chain data
+     * @param address The address to get the declared ranges for
+     * @param intent The declared intent to filter for
+     */
+    getDeclaredCandidateRanges(address: Address, intent: Intent): Promise<Readonly<Readonly<[number, number]>[]>>;
+    /**
+     * Gets the declared candidates for a block based on historical on-chain data
+     * @param block The block number to get the declared candidates for
+     * @param intent The declared intent to filter for
+    */
+    getDeclaredCandidatesForBlock(block: number, intent: Intent): Promise<Address[]>;
+    /**
+     * Gets the required minimum stake for a given intent
+     * @param intent The declared intent to filter for
+     * @returns The required minimum stake for the intent
+     */
+    getRequiredMinimumStakeForIntent(intent: Intent): bigint;
+    /**
+     * Checks if the address is staked for a block for a given intent
+     * @param block The block number to check
+     * @param intent The declared intent to filter for
+     * @param address The address to check
+     */
+    isStakedForBlock(block: number, intent: Intent, address: Address): Promise<boolean>;
+}
+
+/** @deprecated use from @xyo-network/xl1-protocol-sdk instead */
+interface ChainServiceCollection {
+    /**
+     * The account which is used to sign transactions
+     */
+    account: WalletInstance;
+    /**
+     * Services for working with account balances
+     */
+    balanceService: AccountBalanceService;
+    /**
+     * The archivist which the chain data is stored in
+     */
+    chainArchivist: ArchivistInstance;
+    /**
+     * Service for viewing codified chain information
+     * from a contract
+     */
+    chainContractViewer: ChainContractViewer;
+    /**
+     * The chain iterator
+     */
+    chainIterator?: EventingChainBlockNumberIteratorService;
+    /**
+     * Service for viewing stake information
+     */
+    chainStakeViewer: ChainStakeViewer;
+    /**
+     * Service for staking
+     */
+    chainStaker: ChainStaker;
+    /**
+     * The archivist which the chain submissions are stored in
+     */
+    chainSubmissionsArchivistWrite: WriteArchivist;
+    /**
+     * Service for determining leader election
+     */
+    electionService: ElectionService;
+    /**
+     * The archivist which the pending transactions are stored
+     * as bundled transactions
+     */
+    pendingBundledTransactionsArchivistWrite: ArchivistInstance;
+    /**
+     * The block producer service
+     */
+    producer: BlockProducerService;
+    /**
+     * Service response for calculating block rewards
+     */
+    rewardService: BlockRewardService;
+    /**
+     * Services for working with staked intents
+     */
+    stakeIntentService: StakeIntentService;
+}
+
+/** @deprecated use from @xyo-network/xl1-protocol-sdk instead */
+interface ChainServiceCollectionV2 {
+    /**
+     * The account which is used to sign transactions
+     */
+    account: WalletInstance;
+    /**
+     * Services for working with account balances
+     */
+    balanceService: AccountBalanceServiceV2;
+    /**
+     * The archivist which the chain data is stored in
+     */
+    chainArchivist: ArchivistInstance;
+    /**
+     * Service for viewing codified chain information
+     * from a contract
+     */
+    chainContractViewer: ChainContractViewer;
+    /**
+     * The chain iterator
+     */
+    chainIterator?: EventingChainBlockNumberIteratorService;
+    /**
+     * Service for viewing stake information
+     */
+    chainStakeViewer: ChainStakeViewer;
+    /**
+     * Service for staking
+     */
+    chainStaker: ChainStaker;
+    /**
+     * The archivist which the chain submissions are stored in
+     */
+    chainSubmissionsArchivistWrite: WriteArchivist;
+    /**
+     * Service for determining leader election
+     */
+    electionService: ElectionService;
+    /**
+     * The archivist which the pending transactions are stored
+     * as bundled transactions
+     */
+    pendingBundledTransactionsArchivistWrite: ArchivistInstance;
+    /**
+     * The block producer service
+     */
+    producer: BlockProducerService;
+    /**
+     * Service response for calculating block rewards
+     */
+    rewardService: BlockRewardService;
+    /**
+     * Services for working with staked intents
+     */
+    stakeIntentService: StakeIntentService;
+}
+
+interface PendingTransactionsService extends Service {
+    getPendingTransactions(head: Hash, limit: number, timeout?: number): Promise<HydratedTransaction[]>;
+}
+
+declare class ValidationError<TValue = Payload> extends Error {
+    hash: Hash;
+    value: TValue;
+    constructor(hash: Hash, value: TValue, message?: string, cause?: unknown);
+}
+declare const isValidationError: <TValue = Payload>(error: unknown) => error is ValidationError<TValue>;
+
+declare class BlockValidationError extends ValidationError<BlockBoundWitness> {
+}
+declare const isBlockValidationError: (error: unknown) => error is BlockValidationError;
+declare class HydratedBlockValidationError extends ValidationError<HydratedBlock> {
+}
+declare const isHydratedBlockValidationError: (error: unknown) => error is HydratedBlockValidationError;
+declare class HydratedBlockStateValidationError extends ValidationError<HydratedBlock> {
+    chainId: Address;
+    constructor(hash: Hash, chainId: Address, value: HydratedBlock, message?: string, cause?: unknown);
+}
+declare const isHydratedBlockStateValidationError: (error: unknown) => error is HydratedBlockStateValidationError;
+
+type BlockValidatorFunction = (block: BlockBoundWitness, chainId?: Address) => Promisable<BlockValidationError[]>;
+
+/**
+ * A function that validates a hydrated block against chain state.
+ * @param hydratedBlock The hydrated block to validate.
+ * @param chainId The chain ID to use for validation.
+ * @param archivist The archivist to use for validation.
+ * @returns An array of errors if the block is invalid, or an empty array if it is valid.
+ */
+type HydratedBlockStateValidationFunction = (hydratedBlock: HydratedBlock, chainId: Address, services: {
+    accountBalance: AccountBalanceService;
+}) => Promisable<HydratedBlockStateValidationError[]>;
+type HydratedBlockStateValidationFunctionV2 = (hydratedBlock: HydratedBlock, chainId: Address, services: {
+    accountBalance: AccountBalanceServiceV2;
+}) => Promisable<HydratedBlockStateValidationError[]>;
+
+/**
+ * A function that validates a hydrated block.
+ * @param hydratedBlock The hydrated block to validate.
+ * @param chainId The chain ID to use for validation.
+ * @returns An array of errors if the block is invalid, or an empty array if it is valid.
+ */
+type HydratedBlockValidationFunction = (hydratedBlock: HydratedBlock, chainId?: Address) => Promisable<HydratedBlockValidationError[]>;
+
+declare class BoundWitnessValidationError extends ValidationError<BoundWitness> {
+}
+declare const isBoundWitnessValidationError: (error: unknown) => error is BoundWitnessValidationError;
+declare class HydratedBoundWitnessValidationError extends ValidationError<HydratedBoundWitness> {
+}
+declare const isHydratedBoundWitnessValidationError: (error: unknown) => error is HydratedBoundWitnessValidationError;
+
+type BoundWitnessValidationFunction<T extends BoundWitness = BoundWitness> = (bw: T) => Promisable<BoundWitnessValidationError[]>;
+
+type HydratedBoundWitnessWithHashStorageMeta<T extends BoundWitness = BoundWitness, P extends Payload = Payload> = [WithHashStorageMeta<T>, WithHashStorageMeta<P>[]];
+type HydratedBoundWitnessValidationFunction<T extends BoundWitness = BoundWitness> = (bw: HydratedBoundWitnessWithHashStorageMeta<T>) => Promisable<HydratedBoundWitnessValidationError[]>;
+
+declare class InBlockPayloadValidationError extends ValidationError<Payload> {
+    block: HydratedBlock;
+    constructor(hash: Hash, block: HydratedBlock, value: Payload, message?: string, cause?: unknown);
+}
+declare const isInBlockPayloadValidationError: (error: unknown) => error is InBlockPayloadValidationError;
+
+type InBlockPayloadValidationFunction = (payload: WithHashStorageMeta<Payload>, block: HydratedBlock) => Promisable<InBlockPayloadValidationError[]>;
+
+declare class HydratedTransactionValidationError extends ValidationError<HydratedTransaction> {
+}
+declare const isHydratedTransactionValidationError: (error: unknown) => error is HydratedTransactionValidationError;
+
+/**
+ * A function that validates a hydrated transaction against chain state.
+ * @param hydratedTransaction The hydrated transaction to validate.
+ * @param chainId The chain ID to use for validation.
+ * @param archivist The archivist to use for validation.
+ * @returns An array of errors if the transaction is invalid, or an empty array if it is valid.
+ */
+type HydratedTransactionStateValidationFunction<T extends TransactionBoundWitness = TransactionBoundWitness> = (hydratedTransaction: HydratedBoundWitnessWithStorageMeta<T>, chainId: Address, archivist: ReadArchivist) => Promisable<HydratedTransactionValidationError[]>;
+
+/**
+ * A function that validates a hydrated transaction.
+ * @param bw The hydrated transaction to validate.
+ * @param chainId The chain ID to use for validation.
+ * @returns An array of errors if the transaction is invalid, or an empty array if it is valid.
+ */
+type HydratedTransactionValidationFunction<T extends TransactionBoundWitness = TransactionBoundWitness> = (hydratedTransaction: HydratedTransaction<T>, chainId?: Address) => Promisable<HydratedTransactionValidationError[]>;
+
+export { AllowedBlockPayloadSchemas, AttoXL1, AttoXL1ConvertFactor, BlockNumberSchema, BlockValidationError, BoundWitnessValidationError, ChainIndexingServiceStateSchema, ChainStakeIntentSchema, FemtoXL1, HashSchema, HydratedBlockStateValidationError, HydratedBlockValidationError, HydratedBoundWitnessValidationError, HydratedTransactionValidationError, InBlockPayloadValidationError, MicroXL1, MilliXL1, NanoXL1, NetworkStatusSchema, PicoXL1, StepSizes, TransactionGasCosts, TransferSchema, ValidationError, XL1, XL1ConvertDict, XL1Places, XL1_PROTOCOL_VERSION, XL1_PROTOCOL_VERSION_MAJOR, XL1_PROTOCOL_VERSION_MINOR, XL1_PROTOCOL_VERSION_PATCH, XL1_PROTOCOL_VERSION_STRING, asBlockBoundWitness, asBlockBoundWitnessWithHashStorageMeta, asBlockBoundWitnessWithStorageMeta, asBlockNumber, asBlockNumberWithSources, asChainIndexingServiceState, asChainIndexingServiceStateWithStorageMeta, asChainStakeIntent, asExecutable, asHashPayload, asHashPayloadWithStorageMeta, asHydratedBlock, asHydratedTransaction, asSignedBlockBoundWitness, asSignedBlockBoundWitnessWithHashStorageMeta, asSignedBlockBoundWitnessWithStorageMeta, asTransactionBoundWitness, asTransactionBoundWitnessWithHashStorageMeta, asTransactionBoundWitnessWithStorageMeta, asTransfer, asValidStep, defaultTransactionFees, hasFrom, isAllowedBlockPayload, isAllowedBlockPayloadSchema, isAllowedBlockPayloadWithHashStorageMeta, isBlockBoundWitness, isBlockBoundWitnessWithHashStorageMeta, isBlockBoundWitnessWithStorageMeta, isBlockNumber, isBlockNumberWithSources, isBlockValidationError, isBoundWitnessValidationError, isChainIndexingServiceState, isChainIndexingServiceStateWithStorageMeta, isChainStakeIntent, isChainStakeIntentWithStorageMeta, isExecutable, isHashPayload, isHydratedBlock, isHydratedBlockStateValidationError, isHydratedBlockValidationError, isHydratedBoundWitnessValidationError, isHydratedTransaction, isHydratedTransactionValidationError, isInBlockPayloadValidationError, isNetworkStatus, isSigned, isSignedBlockBoundWitness, isSignedBlockBoundWitnessWithHashStorageMeta, isSignedBlockBoundWitnessWithStorageMeta, isSignedTransactionBoundWitness, isSignedTransactionBoundWitnessWithHashStorageMeta, isSignedTransactionBoundWitnessWithStorageMeta, isTransactionBoundWitness, isTransactionBoundWitnessWithHashStorageMeta, isTransactionBoundWitnessWithStorageMeta, isTransfer, isValidStep, isValidationError, minTransactionFees, stepSize, xl1ConvertFactor };
+export type { AccountBalanceService, AccountBalanceServiceV2, Addressable, AllowedBlockPayload, AllowedBlockPayloadSchema, BaseChainService, BlockBoundWitness, BlockBoundWitnessFields, BlockBoundWitnessMeta, BlockDuration, BlockEnd, BlockNumber, BlockNumberFields, BlockProducerService, BlockRewardService, BlockStart, BlockValidatorFunction, BoundWitnessValidationFunction, CaveatTypes, Caveats, ChainAnalyzer, ChainBlockNumberIterator, ChainBlockNumberIteratorService, ChainConnection, ChainContractViewer, ChainHashIterator, ChainHashIteratorService, ChainHeadService, ChainIndexingServiceState, ChainIndexingServiceStateFields, ChainIterator, ChainIteratorEventData, ChainIteratorService, ChainIteratorServiceEventData, ChainReference, ChainService, ChainServiceCollection, ChainServiceCollectionV2, ChainStakeIntent, ChainStakeIntentFields, ChainStakeViewer, ChainStaker, DefaultNetworkIds, ElectionService, EventingChainBlockNumberIterator, EventingChainBlockNumberIteratorService, EventingChainHashIterator, EventingChainHashIteratorService, EventingChainIterator, EventingChainIteratorService, Executable, ExecutableFields, FromFields, HashFields, HashPayload, HeadEventArgs, HeadEventData, HydratedBlock, HydratedBlockStateValidationFunction, HydratedBlockStateValidationFunctionV2, HydratedBlockValidationFunction, HydratedBoundWitnessValidationFunction, HydratedBoundWitnessWithHashStorageMeta, HydratedTransaction, HydratedTransactionStateValidationFunction, HydratedTransactionValidationFunction, InBlockPayloadValidationFunction, Initializable, Intent, InvokerPermission, IterableRepository, IterableTransactionRepository, NetworkId, NetworkStatus, NetworkStatusFields, NetworkStatusState, NetworkStatusUpdate, NextBlockProducer, OpenTelemetryProviders, OptionalBlockDuration, OptionalExecutable, PayloadIterableRepository, PayloadReadRepository, PayloadRepository, PayloadWriteRepository, PendingTransactionsService, Permission, PermissionRequest, ReadRepository, ReadonlyIterableTransactionRepository, RequestedPermission, Service, StakeIntentService, TransactionBoundWitness, TransactionBoundWitnessFields, TransactionFeesBigInt, TransactionFeesFields, TransactionFeesHex, TransactionReadRepository, TransactionRepository, TransactionRepositoryIterator, TransactionWriteRepository, Transfer, TransferFields, TypingFunc, WriteRepository, XyoDataLakeProvider, XyoDataLakeViewer, XyoHost, XyoNetwork, XyoPayloadLakeProvider, XyoPayloadLakeViewer, XyoProvider, XyoRunner, XyoSigner, XyoViewer, XyoWallet };