@xyo-network/xl1-protocol 1.6.1 → 1.7.0-rc.1

package/dist/neutral/index.d.ts

@@ -0,0 +1,829 @@
+import type { Address } from '@xylabs/hex';
+import { AsTypeFunction } from '.store/@xylabs-object-model-npm-4.13.2-4ad0974a5d/package';
+import { BoundWitness } from '@xyo-network/boundwitness-model';
+import type { EmptyObject } from '@xylabs/object';
+import type { EventData } from '@xylabs/events';
+import type { EventEmitter } from '@xylabs/events';
+import { Hash } from '@xylabs/hex';
+import type { Hex } from '@xylabs/hex';
+import type { HydratedBoundWitness } from '@xyo-network/archivist-model';
+import type { HydratedBoundWitnessWithStorageMeta } from '@xyo-network/archivist-model';
+import type { JsonObject } from '@xylabs/object';
+import type { JsonValue } from '@xylabs/object';
+import type { MeterProvider } from '@opentelemetry/api';
+import type { NextOptions } from '@xyo-network/archivist-model';
+import { Payload } from '@xyo-network/payload-model';
+import type { Promisable } from '@xylabs/promise';
+import type { ReadArchivist } from '@xyo-network/archivist-model';
+import type { Schema } from '@xyo-network/payload-model';
+import type { SchemaPayload } from '@xyo-network/schema-payload-plugin';
+import type { Signed } from '@xyo-network/boundwitness-model';
+import type { TracerProvider } from '@opentelemetry/api';
+import type { WithHashStorageMeta } from '@xyo-network/payload-model';
+import type { WithSources } from '@xyo-network/payload-model';
+import { WithStorageMeta } from '@xyo-network/payload-model';
+
+/** @public */
+export declare interface AccountBalanceService extends Service {
+    balances(head: Hash, addresses: Address[]): Promisable<Partial<Record<Address, AttoXL1>>>;
+}
+
+export declare interface Addressable {
+    address: Address;
+}
+
+export declare type AllowedBlockPayload = Transfer | ChainStakeIntent | SchemaPayload | TransactionBoundWitness | HashPayload;
+
+export declare type AllowedBlockPayloadSchema = typeof AllowedBlockPayloadSchemas[number];
+
+export declare const AllowedBlockPayloadSchemas: Schema[];
+
+export declare const asBlockBoundWitness: AsTypeFunction<BlockBoundWitness>;
+
+export declare const asBlockBoundWitnessWithHashStorageMeta: AsTypeFunction<WithHashStorageMeta<BlockBoundWitness>>;
+
+export declare const asBlockBoundWitnessWithStorageMeta: AsTypeFunction<WithStorageMeta<BlockBoundWitness>>;
+
+export declare const asBlockNumber: AsTypeFunction<BlockNumber>;
+
+export declare const asBlockNumberWithSources: AsTypeFunction<WithSources<BlockNumber>>;
+
+/** @public */
+export declare const asChainIndexingServiceState: AsTypeFunction<ChainIndexingServiceState<JsonValue>>;
+
+/** @public */
+export declare const asChainIndexingServiceStateWithStorageMeta: AsTypeFunction<WithStorageMeta<ChainIndexingServiceState<JsonValue>>>;
+
+export declare const asChainStakeIntent: AsTypeFunction<ChainStakeIntent>;
+
+export declare const asExecutable: <T extends EmptyObject>(value: T | undefined) => Executable<T> | undefined;
+
+export declare const asHashPayload: AsTypeFunction<HashPayload>;
+
+export declare const asHashPayloadWithStorageMeta: AsTypeFunction<HashPayload>;
+
+export declare const asHydratedBlock: AsTypeFunction<HydratedBlock<BlockBoundWitness, Payload>>;
+
+export declare const asHydratedTransaction: AsTypeFunction<HydratedTransaction<TransactionBoundWitness, Payload>>;
+
+export declare const asSignedBlockBoundWitness: AsTypeFunction<Signed<BlockBoundWitness>>;
+
+export declare const asSignedBlockBoundWitnessWithHashStorageMeta: AsTypeFunction<Signed<WithHashStorageMeta<BlockBoundWitness>>>;
+
+export declare const asSignedBlockBoundWitnessWithStorageMeta: AsTypeFunction<Signed<WithStorageMeta<BlockBoundWitness>>>;
+
+export declare const asTransactionBoundWitness: AsTypeFunction<TransactionBoundWitness>;
+
+export declare const asTransactionBoundWitnessWithHashStorageMeta: AsTypeFunction<WithHashStorageMeta<TransactionBoundWitness>>;
+
+export declare const asTransactionBoundWitnessWithStorageMeta: AsTypeFunction<WithStorageMeta<TransactionBoundWitness>>;
+
+export declare const asTransfer: AsTypeFunction<Transfer>;
+
+export declare const asValidStep: AsTypeFunction<number>;
+
+export declare type AttoXL1 = bigint & {
+    readonly _tag: 'AttoXL1';
+};
+
+export declare const AttoXL1: TypingFunc<AttoXL1>;
+
+/**
+ * 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.
+ */
+export declare const AttoXL1ConvertFactor: Record<XL1Units, bigint>;
+
+export declare type BlockBoundWitness = BoundWitness<BlockBoundWitnessFields & BlockBoundWitnessMeta>;
+
+export declare 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[];
+}
+
+export declare interface BlockBoundWitnessMeta {
+    $epoch: number;
+}
+
+/**
+ * A duration referenced to block numbers
+ */
+export declare interface BlockDuration extends BlockStart, BlockEnd {
+}
+
+export declare interface BlockEnd {
+    /**
+     * The block at which the duration ends
+     */
+    exp: number;
+}
+
+/**
+ * The number of a block
+ */
+export declare type BlockNumber = Payload<BlockNumberFields, BlockNumberSchema>;
+
+export declare interface BlockNumberFields {
+    /**
+     * The block number
+     */
+    block: Hex;
+}
+
+export declare const BlockNumberSchema: "network.xyo.chain.block.number";
+
+export declare type BlockNumberSchema = typeof BlockNumberSchema;
+
+export declare interface BlockProducerService extends Addressable, NextBlockProducer, Service {
+}
+
+export declare interface BlockRewardService extends Service {
+    getRewardForBlock(block: bigint): Promisable<bigint>;
+}
+
+export declare interface BlockStart {
+    /**
+     * The block at which the duration starts
+     */
+    nbf: number;
+}
+
+export declare class BlockValidationError extends ValidationError<BlockBoundWitness> {
+}
+
+export declare type BlockValidatorFunction = (block: BlockBoundWitness, chainId?: Address) => Promisable<BlockValidationError[]>;
+
+export declare class BoundWitnessValidationError extends ValidationError<BoundWitness> {
+}
+
+export declare type BoundWitnessValidationFunction<T extends BoundWitness = BoundWitness> = (bw: T) => Promisable<BoundWitnessValidationError[]>;
+
+/**
+ * Modeled after EIP-2255
+ * See - https://eips.ethereum.org/EIPS/eip-2255#specification
+ */
+export declare 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;
+}
+
+export declare type CaveatTypes = 'chain' | 'expiration' | 'filteredResponse' | 'rateLimit';
+
+export declare interface ChainAnalyzer<T extends Payload = Payload> {
+    onBlock(block: HydratedBlock): Promisable<boolean>;
+    result(): T;
+    shouldContinue(): boolean;
+}
+
+export declare 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;
+}
+
+export declare interface ChainHeadService extends Service {
+    head(): Promise<Hash>;
+}
+
+export declare interface ChainHeadServiceEventArgs {
+    hash: Hash;
+}
+
+export declare interface ChainHeadServiceEventData extends EventData {
+    headUpdated: ChainHeadServiceEventArgs;
+}
+
+/**
+ * @public
+ * The result of a ChainIndexingServiceState
+ */
+export declare type ChainIndexingServiceState<T extends JsonValue = JsonValue> = Payload<ChainIndexingServiceStateFields<T>, ChainIndexingServiceStateSchema>;
+
+/** @public */
+export declare 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;
+}
+
+/** @public */
+export declare const ChainIndexingServiceStateSchema: "network.xyo.chain.indexing.service.state";
+
+/** @public */
+export declare type ChainIndexingServiceStateSchema = typeof ChainIndexingServiceStateSchema;
+
+export declare interface ChainInformationService {
+    active(): Promisable<bigint>;
+    forkedAtBlockNumber(): Promisable<bigint>;
+    forkedAtHash(): Promisable<bigint>;
+    forkedChainId(): Promisable<Address>;
+    minWithdrawalBlocks(): Promisable<bigint>;
+    rewardsContract(): Promisable<string>;
+    stakingTokenAddress(): Promisable<string>;
+}
+
+/**
+ * Required info for a chain reference
+ */
+export declare interface ChainReference {
+    /**
+     * The contract address referenced by the chain
+     */
+    chain: Address;
+}
+
+export declare type ChainStakeIntent = Payload<ChainStakeIntentFields, ChainStakeIntentSchema>;
+
+export declare interface ChainStakeIntentFields extends BlockDuration, FromFields {
+    intent: Intent;
+}
+
+export declare const ChainStakeIntentSchema: "network.xyo.chain.stake.intent";
+
+export declare type ChainStakeIntentSchema = typeof ChainStakeIntentSchema;
+
+export declare interface ChainStakeService extends ChainStakeViewService {
+    addStake(staked: string, amount: bigint): Promisable<boolean>;
+    removeStake(slot: bigint): Promisable<boolean>;
+    withdrawStake(slot: bigint): Promisable<boolean>;
+}
+
+export declare interface ChainStakeViewService {
+    activeByAddressStaked(address: string): Promisable<bigint>;
+    activeByStaker(address: string): Promisable<bigint>;
+    pending(): Promisable<bigint>;
+    pendingByStaker(staker: string): Promisable<bigint>;
+    withdrawn(): Promisable<bigint>;
+    withdrawnByStaker(staker: string): Promisable<bigint>;
+}
+
+export declare type DefaultNetworkIds = 'mainnet' | 'sequence' | 'local';
+
+export declare const defaultTransactionFees: TransactionFeesBigInt;
+
+export declare interface EventingChainHeadService extends ChainHeadService, EventEmitter<ChainHeadServiceEventData> {
+}
+
+export declare type Executable<T extends EmptyObject = EmptyObject> = T & ExecutableFields;
+
+export declare interface ExecutableFields {
+    script: string[];
+}
+
+export declare type FemtoXL1 = bigint & {
+    readonly _tag: 'FemtoXL1';
+};
+
+export declare const FemtoXL1: TypingFunc<FemtoXL1>;
+
+export declare interface FromFields {
+    from: Address;
+}
+
+export declare const hasFrom: (value: unknown) => value is FromFields;
+
+export declare interface HashFields {
+    hash: Hash;
+}
+
+export declare type HashPayload = Payload<HashFields, HashSchema>;
+
+export declare const HashSchema: "network.xyo.hash";
+
+export declare type HashSchema = typeof HashSchema;
+
+export declare type HydratedBlock<T extends BlockBoundWitness = BlockBoundWitness, P extends Payload = Payload> = [WithStorageMeta<Signed<T>>, WithStorageMeta<P>[]];
+
+export declare class HydratedBlockStateValidationError extends ValidationError<HydratedBlock> {
+    chainId: Address;
+    constructor(hash: Hash, chainId: Address, value: HydratedBlock, message?: string, cause?: unknown);
+}
+
+/**
+ * @public
+ * 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.
+ */
+export declare type HydratedBlockStateValidationFunction = (hydratedBlock: HydratedBlock, chainId: Address, services: {
+    accountBalance: AccountBalanceService;
+}) => Promisable<HydratedBlockStateValidationError[]>;
+
+export declare class HydratedBlockValidationError extends ValidationError<HydratedBlock> {
+}
+
+/**
+ * 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.
+ */
+export declare type HydratedBlockValidationFunction = (hydratedBlock: HydratedBlock, chainId?: Address) => Promisable<HydratedBlockValidationError[]>;
+
+export declare class HydratedBoundWitnessValidationError extends ValidationError<HydratedBoundWitness> {
+}
+
+export declare type HydratedBoundWitnessValidationFunction<T extends BoundWitness = BoundWitness> = (bw: HydratedBoundWitnessWithHashStorageMeta<T>) => Promisable<HydratedBoundWitnessValidationError[]>;
+
+export declare type HydratedBoundWitnessWithHashStorageMeta<T extends BoundWitness = BoundWitness, P extends Payload = Payload> = [WithHashStorageMeta<T>, WithHashStorageMeta<P>[]];
+
+export declare type HydratedTransaction<T extends TransactionBoundWitness = TransactionBoundWitness, P extends Payload = Payload> = [WithStorageMeta<Signed<T>>, WithStorageMeta<P>[]];
+
+/**
+ * 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.
+ */
+export declare type HydratedTransactionStateValidationFunction<T extends TransactionBoundWitness = TransactionBoundWitness> = (hydratedTransaction: HydratedBoundWitnessWithStorageMeta<T>, chainId: Address, archivist: ReadArchivist) => Promisable<HydratedTransactionValidationError[]>;
+
+export declare class HydratedTransactionValidationError extends ValidationError<HydratedTransaction> {
+}
+
+/**
+ * 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.
+ */
+export declare type HydratedTransactionValidationFunction<T extends TransactionBoundWitness = TransactionBoundWitness> = (hydratedTransaction: HydratedTransaction<T>, chainId?: Address) => Promisable<HydratedTransactionValidationError[]>;
+
+export declare class InBlockPayloadValidationError extends ValidationError<Payload> {
+    block: HydratedBlock;
+    constructor(hash: Hash, block: HydratedBlock, value: Payload, message?: string, cause?: unknown);
+}
+
+export declare type InBlockPayloadValidationFunction = (payload: WithHashStorageMeta<Payload>, block: HydratedBlock) => Promisable<InBlockPayloadValidationError[]>;
+
+export declare type Initializable<T, R> = (params: T) => Promisable<R>;
+
+export declare type Intent = 'producer';
+
+export declare interface InvokerPermission extends Permission {
+    /** Time at which the permission was granted */
+    date?: number;
+}
+
+export declare const isAllowedBlockPayload: (value: unknown) => value is AllowedBlockPayload;
+
+export declare const isAllowedBlockPayloadSchema: (value: unknown) => value is AllowedBlockPayloadSchema;
+
+export declare const isAllowedBlockPayloadWithHashStorageMeta: (value: unknown) => value is WithStorageMeta<AllowedBlockPayload>;
+
+export declare const isBlockBoundWitness: (value: unknown) => value is BlockBoundWitness;
+
+export declare const isBlockBoundWitnessWithHashStorageMeta: (value: unknown) => value is WithHashStorageMeta<BlockBoundWitness>;
+
+export declare const isBlockBoundWitnessWithStorageMeta: (value: unknown) => value is WithStorageMeta<BlockBoundWitness>;
+
+/**
+ * Identity function for determining if an object is a BlockNumber
+ */
+export declare const isBlockNumber: (x?: unknown | null) => x is BlockNumber;
+
+/**
+ * Identity function for determining if an object is a BlockNumber with sources
+ */
+export declare const isBlockNumberWithSources: (x?: unknown | null) => x is WithSources<BlockNumber>;
+
+export declare const isBlockValidationError: (error: unknown) => error is BlockValidationError;
+
+export declare const isBoundWitnessValidationError: (error: unknown) => error is BoundWitnessValidationError;
+
+/**
+ * @public
+ * Identity functions for determining if an object is an ChainIndexingServiceState
+ */
+export declare const isChainIndexingServiceState: <T extends JsonValue = JsonValue>(payload?: unknown) => payload is ChainIndexingServiceState<T>;
+
+/** @public */
+export declare const isChainIndexingServiceStateWithStorageMeta: <T extends JsonValue = JsonValue>(value: unknown) => value is WithStorageMeta<ChainIndexingServiceState<T>>;
+
+export declare const isChainStakeIntent: (x?: unknown | null) => x is ChainStakeIntent;
+
+export declare const isExecutable: <T extends EmptyObject>(value: T | undefined) => value is Executable<T>;
+
+export declare const isHashPayload: (x?: unknown | null) => x is HashPayload;
+
+export declare const isHydratedBlock: (value: unknown) => value is HydratedBlock;
+
+export declare const isHydratedBlockStateValidationError: (error: unknown) => error is HydratedBlockStateValidationError;
+
+export declare const isHydratedBlockValidationError: (error: unknown) => error is HydratedBlockValidationError;
+
+export declare const isHydratedBoundWitnessValidationError: (error: unknown) => error is HydratedBoundWitnessValidationError;
+
+export declare const isHydratedTransaction: (value: unknown) => value is HydratedTransaction;
+
+export declare const isHydratedTransactionValidationError: (error: unknown) => error is HydratedTransactionValidationError;
+
+export declare const isInBlockPayloadValidationError: (error: unknown) => error is InBlockPayloadValidationError;
+
+export declare const isNetworkStatus: (x?: unknown | null) => x is NetworkStatus;
+
+/** @public */
+export declare const isService: (value: unknown) => value is Service;
+
+export declare const isSigned: <T extends BoundWitness = BoundWitness>(value: unknown) => value is Signed<T>;
+
+export declare const isSignedBlockBoundWitness: (value: unknown) => value is Signed<BlockBoundWitness>;
+
+export declare const isSignedBlockBoundWitnessWithHashStorageMeta: (value: unknown) => value is Signed<WithHashStorageMeta<BlockBoundWitness>>;
+
+export declare const isSignedBlockBoundWitnessWithStorageMeta: (value: unknown) => value is Signed<WithStorageMeta<BlockBoundWitness>>;
+
+export declare const isSignedTransactionBoundWitness: (value: unknown) => value is Signed<TransactionBoundWitness>;
+
+export declare const isSignedTransactionBoundWitnessWithHashStorageMeta: (value: unknown) => value is WithHashStorageMeta<Signed<TransactionBoundWitness>>;
+
+export declare const isSignedTransactionBoundWitnessWithStorageMeta: (value: unknown) => value is WithStorageMeta<Signed<TransactionBoundWitness>>;
+
+export declare const isTransactionBoundWitness: (value: unknown) => value is TransactionBoundWitness;
+
+export declare const isTransactionBoundWitnessWithHashStorageMeta: (value: unknown) => value is WithHashStorageMeta<TransactionBoundWitness>;
+
+export declare const isTransactionBoundWitnessWithStorageMeta: (value: unknown) => value is WithStorageMeta<TransactionBoundWitness>;
+
+export declare const isTransfer: (x?: unknown | null) => x is Transfer;
+
+export declare const isValidationError: <TValue = Payload>(error: unknown) => error is ValidationError<TValue>;
+
+export declare function isValidStep(step: unknown): step is number;
+
+export declare interface IterableRepository<TId, TData> {
+    next(id: TId): Promisable<TData>;
+}
+
+export declare interface IterableTransactionRepository extends TransactionRepository, TransactionRepositoryIterator {
+}
+
+export declare type MicroXL1 = bigint & {
+    readonly _tag: 'MicroXL1';
+};
+
+export declare const MicroXL1: TypingFunc<MicroXL1>;
+
+export declare type MilliXL1 = bigint & {
+    readonly _tag: 'MilliXL1';
+};
+
+export declare const MilliXL1: TypingFunc<MilliXL1>;
+
+export declare const minTransactionFees: TransactionFeesBigInt;
+
+export declare type NanoXL1 = bigint & {
+    readonly _tag: 'NanoXL1';
+};
+
+export declare const NanoXL1: TypingFunc<NanoXL1>;
+
+export declare type NetworkId<T extends string | void = void> = T extends void ? DefaultNetworkIds : T | DefaultNetworkIds;
+
+export declare type NetworkStatus = Payload<NetworkStatusFields, NetworkStatusSchema>;
+
+export declare interface NetworkStatusFields {
+    description: string;
+    state: NetworkStatusState;
+    updates?: NetworkStatusUpdate[];
+}
+
+export declare const NetworkStatusSchema: "network.xyo.chain.status";
+
+export declare type NetworkStatusSchema = typeof NetworkStatusSchema;
+
+export declare type NetworkStatusState = 'online' | 'offline' | 'degraded' | 'unknown';
+
+export declare type NetworkStatusUpdate = {
+    end: number;
+    start: number;
+    update: string;
+};
+
+export declare type NextBlockProducer = IterableRepository<BlockBoundWitness, HydratedBlock | undefined>;
+
+export declare interface OpenTelemetryProviders {
+    meterProvider?: MeterProvider;
+    traceProvider?: TracerProvider;
+}
+
+/**
+ * A optional duration referenced to block numbers
+ */
+export declare interface OptionalBlockDuration extends Partial<BlockStart>, Partial<BlockEnd> {
+}
+
+export declare type OptionalExecutable<T extends EmptyObject = EmptyObject> = T & Partial<ExecutableFields>;
+
+export declare interface PayloadIterableRepository<TId = Hash, TData extends Payload = Payload> extends IterableRepository<NextOptions<TId>, WithStorageMeta<TData>[]> {
+}
+
+export declare interface PayloadReadRepository<TId = Hash, TData extends Payload = Payload> extends ReadRepository<TId[], WithStorageMeta<TData>[]> {
+}
+
+export declare interface PayloadRepository<TId = Hash, TData extends Payload = Payload> extends PayloadReadRepository<TId, TData>, PayloadWriteRepository<TData>, PayloadIterableRepository<TId, TData> {
+}
+
+export declare interface PayloadWriteRepository<TData extends Payload = Payload> extends WriteRepository<TData[], WithStorageMeta<TData>[]> {
+}
+
+export declare interface PendingTransactionsService extends Service {
+    getPendingTransactions(head: Hash, limit: number, timeout?: number): Promise<HydratedTransaction[]>;
+}
+
+/**
+ * Modeled after EIP-2255
+ * See - https://eips.ethereum.org/EIPS/eip-2255#specification
+ */
+export declare 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;
+}
+
+/**
+ * Modeled after EIP-2255
+ * See - https://eips.ethereum.org/EIPS/eip-2255#specification
+ */
+export declare interface PermissionRequest {
+    [capability: string]: {
+        [caveatName: string]: JsonValue;
+    };
+}
+
+export declare type PicoXL1 = bigint & {
+    readonly _tag: 'PicoXL1';
+};
+
+export declare const PicoXL1: TypingFunc<PicoXL1>;
+
+export declare interface ProducerElectionService extends Service {
+    /**
+     * Given the current block, get the leader for the next block
+     * @param current The previous block
+     */
+    getCreatorCommitteeForNextBlock(current: BlockBoundWitness): Promise<Address[]>;
+}
+
+export declare interface ReadonlyIterableTransactionRepository extends TransactionReadRepository, TransactionRepositoryIterator {
+}
+
+export declare interface ReadRepository<TId, TData> {
+    get(id: TId): Promisable<TData>;
+}
+
+/**
+ * Modeled after EIP-2255
+ * See - https://eips.ethereum.org/EIPS/eip-2255#specification
+ */
+export declare interface RequestedPermission {
+    /** Permission identifier (i.e. RPC method, action, etc.) */
+    capability: string;
+    /** Optional timestamp for when the permission was granted */
+    date?: number;
+}
+
+/** @public */
+export declare interface Service {
+    /** @description Service Function Interface */
+    sfi(): Promisable<JsonObject>;
+}
+
+/** @public */
+export declare 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>;
+}
+
+export declare function stepSize(step: number): number;
+
+export declare const StepSizes: readonly [7, 31, 211, 2311, 30031, 510511, 9699691, 223092871, 6469693231];
+
+export declare type TransactionBoundWitness = BoundWitness<TransactionBoundWitnessFields & OptionalExecutable & FromFields>;
+
+export declare interface TransactionBoundWitnessFields extends BlockDuration, TransactionFeesFields {
+    chain: Address;
+}
+
+export declare interface TransactionFeesBigInt {
+    base: AttoXL1;
+    gasLimit: AttoXL1;
+    gasPrice: AttoXL1;
+    priority: AttoXL1;
+}
+
+export declare interface TransactionFeesFields {
+    fees: TransactionFeesHex;
+}
+
+export declare type TransactionFeesHex = {
+    [K in keyof TransactionFeesBigInt]: Hex;
+};
+
+export 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;
+};
+
+export declare interface TransactionReadRepository extends ReadRepository<TransactionBoundWitness, HydratedTransaction | undefined> {
+}
+
+export declare interface TransactionRepository extends TransactionReadRepository, TransactionWriteRepository {
+}
+
+export declare interface TransactionRepositoryIterator extends IterableRepository<TransactionBoundWitness, HydratedTransaction | undefined> {
+}
+
+export declare interface TransactionWriteRepository extends WriteRepository<HydratedTransaction, boolean> {
+}
+
+export declare type Transfer = Payload<TransferFields, TransferSchema>;
+
+export declare interface TransferFields extends FromFields {
+    epoch: number;
+    transfers: Partial<Record<Address, Hex>>;
+}
+
+export declare const TransferSchema: "network.xyo.transfer";
+
+export declare type TransferSchema = typeof TransferSchema;
+
+export declare type TypingFunc<T extends bigint> = (value: bigint) => T;
+
+export declare class ValidationError<TValue = Payload> extends Error {
+    hash: Hash;
+    value: TValue;
+    constructor(hash: Hash, value: TValue, message?: string, cause?: unknown);
+}
+
+export declare interface WriteRepository<TData, TResp> {
+    insert(data: TData): Promisable<TResp>;
+}
+
+export declare type XL1 = bigint & {
+    readonly _tag: 'XL1';
+};
+
+export declare const XL1: TypingFunc<XL1>;
+
+export declare const XL1_PROTOCOL_VERSION: number;
+
+export declare const XL1_PROTOCOL_VERSION_MAJOR: 1;
+
+export declare const XL1_PROTOCOL_VERSION_MINOR: 2;
+
+export declare const XL1_PROTOCOL_VERSION_PATCH: 0;
+
+export declare const XL1_PROTOCOL_VERSION_STRING: "1.2.0";
+
+/** @deprecated use XL1Places and xl1ConvertFactor(unit) instead */
+export declare const XL1ConvertDict: Record<XL1Units, number>;
+
+/** @deprecated use AttoXL1ConvertFactor instead */
+export declare function xl1ConvertFactor(unit: XL1Units): bigint;
+
+export declare const XL1Places: Record<XL1Units, bigint>;
+
+declare type XL1Units = 'xl1' | 'milli' | 'micro' | 'nano' | 'pico' | 'femto' | 'atto';
+
+export declare interface XyoDataLakeProvider extends XyoDataLakeViewer, XyoPayloadLakeProvider {
+    add(items: ArrayBuffer[]): Promisable<Hash[]>;
+}
+
+export declare 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[]][]>;
+}
+
+export declare interface XyoHost {
+    addChain(chainConnectionInfo: ChainConnection): Promisable<boolean>;
+    chains(): Promisable<ChainConnection[]>;
+    getPermissions(): Promisable<InvokerPermission[]>;
+    requestPermissions(permissions: Permission[]): Promisable<boolean>;
+    revokePermissions(permissions: Permission[]): Promisable<boolean>;
+}
+
+export declare interface XyoNetwork {
+    status(): Promisable<NetworkStatus>;
+}
+
+export declare interface XyoPayloadLakeProvider extends XyoPayloadLakeViewer {
+    addPayloads(payloads: Payload[]): Promisable<Hash[]>;
+}
+
+export declare interface XyoPayloadLakeViewer {
+    getPayloads(hashes: Hash[]): Promisable<Payload[]>;
+}
+
+export declare 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;
+}
+
+export declare interface XyoRunner {
+    broadcastTransaction(transaction: HydratedTransaction): Promisable<Hash>;
+}
+
+export declare interface XyoSigner {
+    address(): Promisable<Address>;
+    createSignedTransaction(chain: Address, elevatedPayloads: AllowedBlockPayload[], additionalPayloads: Payload[], nbf: number, exp: number, fees: TransactionFeesBigInt, from?: Address): Promisable<Signed<TransactionBoundWitness>>;
+}
+
+export declare 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 */
+export declare 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>;
+}
+
+export { }