@xyo-network/xl1-protocol 1.3.30 → 1.3.32

package/dist/index.d.ts

@@ -0,0 +1,501 @@
+import * as _xylabs_promise from '@xylabs/promise';
+import { Promisable } from '@xylabs/promise';
+import { MeterProvider, TracerProvider, Meter, Tracer } from '@opentelemetry/api';
+import { Payload, WithSources, WithStorageMeta, WithHashStorageMeta, Schema } from '@xyo-network/payload-model';
+import { SchemaPayload } from '@xyo-network/schema-payload-plugin';
+import * as _xylabs_object from '@xylabs/object';
+import { EmptyObject, JsonValue } from '@xylabs/object';
+import { Address, Hex, Hash } from '@xylabs/hex';
+import { BoundWitness, Signed } from '@xyo-network/boundwitness-model';
+import { BaseParams } from '@xylabs/base';
+import { EventData, BaseEmitter } from '@xylabs/events';
+import { ArchivistInstance, WriteArchivist, ReadArchivist, HydratedBoundWitnessWithStorageMeta } from '@xyo-network/archivist-model';
+import { AccountInstance } from '@xyo-network/account-model';
+import { Logger } from '@xylabs/logger';
+import { WalletInstance } from '@xyo-network/wallet-model';
+
+type Initializable<T, R> = (params: T) => Promisable<R>;
+
+interface OpenTelemetryProviders {
+    meterProvider?: MeterProvider;
+    traceProvider?: TracerProvider;
+}
+
+type XL1 = bigint & {
+    readonly _tag: 'XL1';
+};
+declare const XL1: (value: bigint) => XL1;
+type MicroXL1 = bigint & {
+    readonly _tag: 'MicroXL1';
+};
+declare const MicroXL1: (value: bigint) => MicroXL1;
+declare const mXL1ToXL1: (value: MicroXL1) => XL1;
+declare const mXL1FromXL1: (value: XL1) => MicroXL1;
+
+interface Addressable {
+    address: Address;
+}
+
+interface BlockStart {
+    nbf: number;
+}
+interface BlockEnd {
+    exp: number;
+}
+interface OptionalBlockDuration extends Partial<BlockStart>, Partial<BlockEnd> {
+}
+interface BlockDuration extends BlockStart, BlockEnd {
+}
+
+declare const BlockNumberSchema: "network.xyo.chain.block.number";
+type BlockNumberSchema = typeof BlockNumberSchema;
+interface BlockNumberFields {
+    block: Hex;
+    chain?: Hex;
+}
+type BlockNumber = Payload<BlockNumberFields, BlockNumberSchema>;
+declare const isBlockNumber: (x?: unknown | null) => x is BlockNumber;
+declare const asBlockNumber: {
+    <TType extends BlockNumber>(value: _xylabs_promise.AnyNonPromise, config?: _xylabs_object.TypeCheckConfig): TType | undefined;
+    <TType extends BlockNumber>(value: _xylabs_promise.AnyNonPromise, assert: _xylabs_object.StringOrAlertFunction<BlockNumber>, config?: _xylabs_object.TypeCheckConfig): TType;
+};
+declare const asOptionalBlockNumber: <TType extends BlockNumber>(value: _xylabs_promise.AnyNonPromise) => TType | undefined;
+declare const isBlockNumberWithSources: (x?: unknown | null) => x is WithSources<BlockNumber>;
+declare const asBlockNumberWithSources: {
+    <TType extends WithSources<BlockNumber>>(value: _xylabs_promise.AnyNonPromise, config?: _xylabs_object.TypeCheckConfig): TType | undefined;
+    <TType extends WithSources<BlockNumber>>(value: _xylabs_promise.AnyNonPromise, assert: _xylabs_object.StringOrAlertFunction<WithSources<BlockNumber>>, config?: _xylabs_object.TypeCheckConfig): TType;
+};
+declare const asOptionalBlockNumberWithSources: <TType extends WithSources<BlockNumber>>(value: _xylabs_promise.AnyNonPromise) => TType | undefined;
+
+interface ChainReference {
+    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: {
+    <TType extends ChainStakeIntent>(value: _xylabs_promise.AnyNonPromise, config?: _xylabs_object.TypeCheckConfig): TType | undefined;
+    <TType extends ChainStakeIntent>(value: _xylabs_promise.AnyNonPromise, assert: _xylabs_object.StringOrAlertFunction<ChainStakeIntent>, config?: _xylabs_object.TypeCheckConfig): TType;
+};
+declare const asOptionalChainStakeIntent: <TType extends ChainStakeIntent>(value: _xylabs_promise.AnyNonPromise) => TType | undefined;
+
+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: {
+    <TType extends HashPayload>(value: _xylabs_promise.AnyNonPromise, config?: _xylabs_object.TypeCheckConfig): TType | undefined;
+    <TType extends HashPayload>(value: _xylabs_promise.AnyNonPromise, assert: _xylabs_object.StringOrAlertFunction<HashPayload>, config?: _xylabs_object.TypeCheckConfig): TType;
+};
+declare const asHashPayloadWithStorageMeta: {
+    <TType extends HashPayload>(value: _xylabs_promise.AnyNonPromise, config?: _xylabs_object.TypeCheckConfig): TType | undefined;
+    <TType extends HashPayload>(value: _xylabs_promise.AnyNonPromise, assert: _xylabs_object.StringOrAlertFunction<HashPayload>, config?: _xylabs_object.TypeCheckConfig): TType;
+};
+declare const asOptionalHashPayload: <TType extends HashPayload>(value: _xylabs_promise.AnyNonPromise) => TType | undefined;
+
+declare const TransferSchema: "network.xyo.transfer";
+type TransferSchema = typeof TransferSchema;
+interface TransferFields extends FromFields {
+    epoch: number;
+    transfers: Record<Address, Hex>;
+}
+type Transfer = Payload<TransferFields, TransferSchema>;
+declare const isTransfer: (x?: unknown | null) => x is Transfer;
+declare const asTransfer: {
+    <TType extends Transfer>(value: _xylabs_promise.AnyNonPromise, config?: _xylabs_object.TypeCheckConfig): TType | undefined;
+    <TType extends Transfer>(value: _xylabs_promise.AnyNonPromise, assert: _xylabs_object.StringOrAlertFunction<Transfer>, config?: _xylabs_object.TypeCheckConfig): TType;
+};
+declare const asOptionalTransfer: <TType extends Transfer>(value: _xylabs_promise.AnyNonPromise) => TType | undefined;
+
+interface TransactionFeesBigInt {
+    base: MicroXL1;
+    gasLimit: MicroXL1;
+    gasPrice: MicroXL1;
+    priority: MicroXL1;
+}
+type TransactionFeesHex = {
+    [K in keyof TransactionFeesBigInt]: Hex;
+};
+interface TransactionFeesFields {
+    fees: TransactionFeesHex;
+}
+declare const minTransactionFees: TransactionFeesBigInt;
+declare const defaultTransactionFees: TransactionFeesBigInt;
+
+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 isSignedTransactionBoundWitnessWithStorageMeta: (value: unknown) => value is WithStorageMeta<Signed<TransactionBoundWitness>>;
+declare const asTransactionBoundWitness: {
+    <TType extends TransactionBoundWitness>(value: _xylabs_promise.AnyNonPromise, config?: _xylabs_object.TypeCheckConfig): TType | undefined;
+    <TType extends TransactionBoundWitness>(value: _xylabs_promise.AnyNonPromise, assert: _xylabs_object.StringOrAlertFunction<TransactionBoundWitness>, config?: _xylabs_object.TypeCheckConfig): TType;
+};
+declare const asOptionalTransactionBoundWitness: <TType extends TransactionBoundWitness>(value: _xylabs_promise.AnyNonPromise) => TType | undefined;
+declare const asTransactionBoundWitnessWithStorageMeta: {
+    <TType extends WithStorageMeta<TransactionBoundWitness>>(value: _xylabs_promise.AnyNonPromise, config?: _xylabs_object.TypeCheckConfig): TType | undefined;
+    <TType extends WithStorageMeta<TransactionBoundWitness>>(value: _xylabs_promise.AnyNonPromise, assert: _xylabs_object.StringOrAlertFunction<WithStorageMeta<TransactionBoundWitness>>, config?: _xylabs_object.TypeCheckConfig): TType;
+};
+declare const asOptionalTransactionBoundWitnessWithStorageMeta: <TType extends WithStorageMeta<TransactionBoundWitness>>(value: _xylabs_promise.AnyNonPromise) => TType | undefined;
+
+type HydratedTransaction<T extends TransactionBoundWitness = TransactionBoundWitness, P extends Payload = Payload> = [T, P[]];
+type HydratedTransactionWithStorageMeta<T extends HydratedTransaction = HydratedTransaction> = [WithStorageMeta<T[0]>, WithStorageMeta<T[1][number]>[]];
+type HydratedTransactionWithHashStorageMeta<T extends HydratedTransaction = HydratedTransaction> = [WithHashStorageMeta<T[0]>, WithHashStorageMeta<T[1][number]>[]];
+type SignedHydratedTransaction<T extends HydratedTransaction = HydratedTransaction> = [Signed<T[0]>, T[1][number][]] & HydratedTransaction;
+type SignedHydratedTransactionWithStorageMeta<T extends HydratedTransaction = HydratedTransaction> = [WithStorageMeta<Signed<T[0]>>, WithStorageMeta<T[1][number]>[]] & SignedHydratedTransaction<T> & HydratedTransaction;
+
+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;
+    chain: Hex;
+    previous: Hash | null;
+    protocol: number;
+    step_hashes: Hex[];
+}
+type BlockBoundWitness = BoundWitness<BlockBoundWitnessFields & BlockBoundWitnessMeta>;
+declare const isBlockBoundWitness: (value: unknown) => value is BlockBoundWitness;
+declare const isBlockBoundWitnessWithStorageMeta: (value: unknown) => value is WithStorageMeta<BlockBoundWitness>;
+declare const asBlockBoundWitness: {
+    <TType extends BlockBoundWitness>(value: _xylabs_promise.AnyNonPromise, config?: _xylabs_object.TypeCheckConfig): TType | undefined;
+    <TType extends BlockBoundWitness>(value: _xylabs_promise.AnyNonPromise, assert: _xylabs_object.StringOrAlertFunction<BlockBoundWitness>, config?: _xylabs_object.TypeCheckConfig): TType;
+};
+declare const asOptionalBlockBoundWitness: <TType extends BlockBoundWitness>(value: _xylabs_promise.AnyNonPromise) => TType | undefined;
+declare const asBlockBoundWitnessWithStorageMeta: {
+    <TType extends WithStorageMeta<BlockBoundWitness>>(value: _xylabs_promise.AnyNonPromise, config?: _xylabs_object.TypeCheckConfig): TType | undefined;
+    <TType extends WithStorageMeta<BlockBoundWitness>>(value: _xylabs_promise.AnyNonPromise, assert: _xylabs_object.StringOrAlertFunction<WithStorageMeta<BlockBoundWitness>>, config?: _xylabs_object.TypeCheckConfig): TType;
+};
+declare const asOptionalBlockBoundWitnessWithStorageMeta: <TType extends WithStorageMeta<BlockBoundWitness>>(value: _xylabs_promise.AnyNonPromise) => TType | undefined;
+
+type HydratedBlock = [WithStorageMeta<BlockBoundWitness>, WithStorageMeta<Payload>[]];
+type SignedHydratedBlock = [WithStorageMeta<Signed<BlockBoundWitness>>, WithStorageMeta<Payload>[]] & HydratedBlock;
+
+interface ChainAnalyzer<T extends Payload = Payload> {
+    onBlock(block: HydratedBlock): Promisable<boolean>;
+    result(): T;
+    shouldContinue(): boolean;
+}
+
+declare const StepSizes: readonly [10, 105, 1103, 11576, 121551, 1276282, 13400956];
+
+declare const TransactionGasCosts: {
+    readonly characterStorage: MicroXL1;
+    readonly payloadValidation: MicroXL1;
+    readonly signatureValidation: MicroXL1;
+    readonly hashValidation: MicroXL1;
+    readonly balanceValidation: MicroXL1;
+};
+
+interface ReadRepository<TId, TData> {
+    get(id: TId): Promise<TData | undefined>;
+}
+interface IterableRepository<TId, TData> {
+    next(id: TId): Promise<TData | undefined>;
+}
+interface WriteRepository<TData, TResp> {
+    insert(data: TData): Promise<TResp>;
+}
+
+interface TransactionReadRepository extends ReadRepository<TransactionBoundWitness, HydratedTransaction> {
+}
+
+interface TransactionRepositoryIterator extends IterableRepository<TransactionBoundWitness, HydratedTransaction> {
+}
+
+interface TransactionWriteRepository extends WriteRepository<HydratedTransaction, boolean> {
+}
+
+interface TransactionRepository extends TransactionReadRepository, TransactionWriteRepository {
+}
+interface ReadonlyIterableTransactionRepository extends TransactionReadRepository, TransactionRepositoryIterator {
+}
+interface IterableTransactionRepository extends TransactionRepository, TransactionRepositoryIterator {
+}
+
+interface AccountBalanceService {
+    getBalanceValue?: (address: Address) => bigint;
+    getBalanceValues?: Record<Address, bigint>;
+    getBalance(address: Address): Hex;
+    getBalances(): Record<Address, Hex>;
+    sync(head: Hash): Promise<void>;
+}
+
+type NextBlockProducer = IterableRepository<BlockBoundWitness, HydratedBlock>;
+interface BlockProducer extends Addressable, NextBlockProducer {
+}
+
+type ServiceName = Exclude<string, 'reserved-service-name-value'>;
+interface Service {
+    logger?: Logger;
+    meter?: Meter;
+    tracer?: Tracer;
+}
+
+interface BlockRewardService extends Service {
+    getRewardForBlock(block: bigint): Promisable<bigint>;
+}
+
+interface ChainContractViewer {
+    active(): Promise<bigint>;
+    chainId(): Promise<Address>;
+    forkedAtBlockNumber(): Promise<bigint>;
+    forkedAtHash(): Promise<bigint>;
+    forkedChainId(): Promise<Address>;
+    minWithdrawalBlocks(): Promise<bigint>;
+    rewardsContract(): Promise<string>;
+    stakingTokenAddress(): Promise<string>;
+}
+
+declare const ChainIdentificationPayloadSchema: "network.xyo.chain.identification";
+type ChainIdentificationPayloadSchema = typeof ChainIdentificationPayloadSchema;
+interface ChainIdentification {
+    id: Address;
+}
+type ChainIdentificationPayload = Payload<ChainIdentification, ChainIdentificationPayloadSchema>;
+declare const isChainIdentificationPayload: (x?: unknown | null) => x is ChainIdentificationPayload;
+
+declare const ChainInformationPayloadSchema: "network.xyo.chain.information";
+type ChainInformationPayloadSchema = typeof ChainInformationPayloadSchema;
+
+interface ChainInformation extends ChainIdentification {
+}
+type ChainInformationPayload = Payload<ChainIdentification, ChainInformationPayloadSchema>;
+declare const isChainInformationPayload: (x?: unknown | null) => x is ChainInformationPayload;
+
+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 ChainInformation, ChainContractViewer, ChainStakeViewer, ChainStaker, Service {
+}
+
+interface ElectionService extends Service {
+    getCreatorCommitteeForNextBlock(current: BlockBoundWitness): Promise<Address[]>;
+}
+
+interface ChainIndexingServiceStateFields<T extends JsonValue = JsonValue> {
+    endBlockHash: Hash;
+    startBlockHash?: Hash;
+    state: T;
+}
+declare const ChainIndexingServiceStateSchema: "network.xyo.chain.indexing.service.state";
+type ChainIndexingServiceStateSchema = typeof ChainIndexingServiceStateSchema;
+type ChainIndexingServiceState<T extends JsonValue = JsonValue> = Payload<ChainIndexingServiceStateFields<T>, ChainIndexingServiceStateSchema>;
+declare const isChainIndexingServiceState: <T extends JsonValue = JsonValue>(payload?: unknown) => payload is ChainIndexingServiceState<T>;
+declare const asChainIndexingServiceState: {
+    <TType extends ChainIndexingServiceState<JsonValue>>(value: _xylabs_promise.AnyNonPromise, config?: _xylabs_object.TypeCheckConfig): TType | undefined;
+    <TType extends ChainIndexingServiceState<JsonValue>>(value: _xylabs_promise.AnyNonPromise, assert: _xylabs_object.StringOrAlertFunction<ChainIndexingServiceState<JsonValue>>, config?: _xylabs_object.TypeCheckConfig): TType;
+};
+declare const isChainIndexingServiceStateWithStorageMeta: <T extends JsonValue = JsonValue>(value: unknown) => value is WithStorageMeta<ChainIndexingServiceState<T>>;
+declare const asChainIndexingServiceStateWithStorageMeta: {
+    <TType extends WithStorageMeta<ChainIndexingServiceState<JsonValue>>>(value: _xylabs_promise.AnyNonPromise, config?: _xylabs_object.TypeCheckConfig): TType | undefined;
+    <TType extends WithStorageMeta<ChainIndexingServiceState<JsonValue>>>(value: _xylabs_promise.AnyNonPromise, assert: _xylabs_object.StringOrAlertFunction<WithStorageMeta<ChainIndexingServiceState<JsonValue>>>, config?: _xylabs_object.TypeCheckConfig): TType;
+};
+declare const asOptionalChainIndexingServiceStateWithStorageMeta: <TType extends WithStorageMeta<ChainIndexingServiceState<JsonValue>>>(value: _xylabs_promise.AnyNonPromise) => TType | undefined;
+
+interface StakeIntentService {
+    getDeclaredCandidateRanges(address: Address, intent: Intent): Promise<Readonly<Readonly<[number, number]>[]>>;
+    getDeclaredCandidatesForBlock(block: number, intent: Intent): Promise<Address[]>;
+    isStakedForBlock(block: number, intent: Intent, address: Address): Promise<boolean>;
+}
+
+interface ChainServiceCollection {
+    account: WalletInstance;
+    balanceService: AccountBalanceService;
+    chainArchivist: ArchivistInstance;
+    chainContractViewer: ChainContractViewer;
+    chainInformation: ChainInformation;
+    chainIterator?: EventingChainBlockNumberIterator;
+    chainStakeViewer: ChainStakeViewer;
+    chainStaker: ChainStaker;
+    chainSubmissionsArchivistWrite: WriteArchivist;
+    electionService: ElectionService;
+    producer: BlockProducer;
+    rewardService: BlockRewardService;
+    stakeIntentService: StakeIntentService;
+}
+
+type BaseServiceParams<TAdditionalParams extends EmptyObject = EmptyObject> = BaseParams<TAdditionalParams & OpenTelemetryProviders>;
+type BaseAccountableServiceParams = BaseServiceParams<{
+    account: AccountInstance;
+}>;
+
+interface PendingTransactionsService extends Service {
+    getPendingTransactions(head: Hash, limit: number, timeout?: number): Promise<HydratedTransaction[]>;
+}
+
+type HeadEventArgs = {
+    blocks: [BlockBoundWitness];
+};
+interface HeadEventData extends EventData {
+    headUpdated: HeadEventArgs;
+}
+interface ChainIteratorEventData extends HeadEventData {
+}
+
+interface ChainIterator<TKey, THead> extends ReadRepository<TKey, BlockBoundWitness>, IterableRepository<TKey, BlockBoundWitness> {
+    chainIdentification: ChainIdentification;
+    head(): Promise<THead>;
+    previous(cursor?: TKey | undefined, limit?: number): Promise<BlockBoundWitness[]>;
+    updateHead(head: THead): Promise<void>;
+}
+interface EventingChainIterator<TKey, THead> extends ChainIterator<TKey, THead>, BaseEmitter<BaseParams, ChainIteratorEventData> {
+}
+interface ChainBlockNumberIterator extends ChainIterator<number, BlockBoundWitness> {
+}
+interface EventingChainBlockNumberIterator extends EventingChainIterator<number, BlockBoundWitness> {
+}
+interface ChainHashIterator extends ChainIterator<Hash, Hash> {
+}
+interface EventingChainHashIterator extends EventingChainIterator<Hash, Hash> {
+}
+interface XyoChainIteratorParams extends BaseServiceParams {
+    chainArchivist: ArchivistInstance;
+    head: BlockBoundWitness;
+}
+
+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 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 XyoNetwork {
+    status(): Promisable<NetworkStatus>;
+}
+
+interface XyoRunner {
+    broadcastTransaction(transaction: SignedHydratedTransaction): 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<SignedHydratedBlock | null>;
+    blockByNumber(blockNumber: number): Promisable<SignedHydratedBlock | null>;
+    blocksByHash(hash: Hash, limit?: number): Promisable<SignedHydratedBlock[]>;
+    chainId(): Promisable<Address>;
+    currentBlock(): Promisable<SignedHydratedBlock>;
+    currentBlockHash(): Promisable<Hash>;
+    currentBlockNumber(): Promisable<number>;
+    transactionByBlockHashAndIndex(blockHash: Hash, transactionIndex: number): Promisable<SignedHydratedTransaction | null>;
+    transactionByBlockNumberAndIndex(blockNumber: number, transactionIndex: number): Promisable<SignedHydratedTransaction | null>;
+    transactionByHash(transactionHash: Hash): Promisable<SignedHydratedTransaction | null>;
+}
+
+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 {
+    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;
+    wallet?: XyoWallet;
+}
+
+type BlockValidatorFunction = (block: BlockBoundWitness, chainId?: Address) => Promisable<Error[]>;
+
+type HydratedBlockStateValidationFunction = (hydratedBlock: HydratedBlock, chainId: Address, archivist: ReadArchivist) => Promisable<Error[]>;
+
+type HydratedBlockValidatorFunction = (hydratedBlock: HydratedBlock, chainId?: Address) => Promisable<Error[]>;
+
+type BoundWitnessValidationFunction<T extends BoundWitness = BoundWitness> = (bw: T) => Promisable<Error[]>;
+
+type HydratedBoundWitnessWithHashStorageMeta<T extends BoundWitness = BoundWitness, P extends Payload = Payload> = [WithHashStorageMeta<T>, WithHashStorageMeta<P>[]];
+type HydratedBoundWitnessValidationFunction<T extends BoundWitness = BoundWitness> = (bw: HydratedBoundWitnessWithHashStorageMeta<T>) => Promisable<Error[]>;
+
+type InBlockPayloadValidationFunction = (payload: WithHashStorageMeta<Payload>, block: HydratedBlock) => Promisable<Error[]>;
+
+type HydratedTransactionStateValidationFunction<T extends TransactionBoundWitness = TransactionBoundWitness> = (hydratedTransaction: HydratedBoundWitnessWithStorageMeta<T>, chainId: Address, archivist: ReadArchivist) => Promisable<Error[]>;
+
+type HydratedTransactionValidatorFunction<T extends TransactionBoundWitness = TransactionBoundWitness> = (hydratedTransaction: HydratedTransactionWithHashStorageMeta<HydratedTransaction<T>>, chainId?: Address) => Promisable<Error[]>;
+
+export { type AccountBalanceService, type Addressable, type AllowedBlockPayload, type AllowedBlockPayloadSchema, AllowedBlockPayloadSchemas, type BaseAccountableServiceParams, type BaseServiceParams, type BlockBoundWitness, type BlockBoundWitnessFields, type BlockBoundWitnessMeta, type BlockDuration, type BlockEnd, type BlockNumber, type BlockNumberFields, BlockNumberSchema, type BlockProducer, type BlockRewardService, type BlockStart, type BlockValidatorFunction, type BoundWitnessValidationFunction, type ChainAnalyzer, type ChainBlockNumberIterator, type ChainContractViewer, type ChainHashIterator, type ChainIdentification, type ChainIdentificationPayload, ChainIdentificationPayloadSchema, type ChainIndexingServiceState, type ChainIndexingServiceStateFields, ChainIndexingServiceStateSchema, type ChainInformation, type ChainInformationPayload, ChainInformationPayloadSchema, type ChainIterator, type ChainIteratorEventData, type ChainReference, type ChainService, type ChainServiceCollection, type ChainStakeIntent, type ChainStakeIntentFields, ChainStakeIntentSchema, type ChainStakeViewer, type ChainStaker, type DefaultNetworkIds, type ElectionService, type EventingChainBlockNumberIterator, type EventingChainHashIterator, type EventingChainIterator, type Executable, type ExecutableFields, type FromFields, type HashFields, type HashPayload, HashSchema, type HeadEventArgs, type HeadEventData, type HydratedBlock, type HydratedBlockStateValidationFunction, type HydratedBlockValidatorFunction, type HydratedBoundWitnessValidationFunction, type HydratedBoundWitnessWithHashStorageMeta, type HydratedTransaction, type HydratedTransactionStateValidationFunction, type HydratedTransactionValidatorFunction, type HydratedTransactionWithHashStorageMeta, type HydratedTransactionWithStorageMeta, type InBlockPayloadValidationFunction, type Initializable, type Intent, type IterableRepository, type IterableTransactionRepository, MicroXL1, type NetworkId, type NetworkStatus, type NetworkStatusFields, NetworkStatusSchema, type NetworkStatusState, type NetworkStatusUpdate, type NextBlockProducer, type OpenTelemetryProviders, type OptionalBlockDuration, type OptionalExecutable, type PendingTransactionsService, type ReadRepository, type ReadonlyIterableTransactionRepository, type Service, type ServiceName, type SignedHydratedBlock, type SignedHydratedTransaction, type SignedHydratedTransactionWithStorageMeta, type StakeIntentService, StepSizes, type TransactionBoundWitness, type TransactionBoundWitnessFields, type TransactionFeesBigInt, type TransactionFeesFields, type TransactionFeesHex, TransactionGasCosts, type TransactionReadRepository, type TransactionRepository, type TransactionRepositoryIterator, type TransactionWriteRepository, type Transfer, type TransferFields, TransferSchema, type WriteRepository, XL1, type XyoChainIteratorParams, type XyoDataLakeProvider, type XyoDataLakeViewer, type XyoNetwork, type XyoPayloadLakeProvider, type XyoPayloadLakeViewer, type XyoProvider, type XyoRunner, type XyoSigner, type XyoViewer, type XyoWallet, asBlockBoundWitness, asBlockBoundWitnessWithStorageMeta, asBlockNumber, asBlockNumberWithSources, asChainIndexingServiceState, asChainIndexingServiceStateWithStorageMeta, asChainStakeIntent, asExecutable, asHashPayload, asHashPayloadWithStorageMeta, asOptionalBlockBoundWitness, asOptionalBlockBoundWitnessWithStorageMeta, asOptionalBlockNumber, asOptionalBlockNumberWithSources, asOptionalChainIndexingServiceStateWithStorageMeta, asOptionalChainStakeIntent, asOptionalHashPayload, asOptionalTransactionBoundWitness, asOptionalTransactionBoundWitnessWithStorageMeta, asOptionalTransfer, asTransactionBoundWitness, asTransactionBoundWitnessWithStorageMeta, asTransfer, defaultTransactionFees, hasFrom, isAllowedBlockPayload, isAllowedBlockPayloadSchema, isAllowedBlockPayloadWithHashStorageMeta, isBlockBoundWitness, isBlockBoundWitnessWithStorageMeta, isBlockNumber, isBlockNumberWithSources, isChainIdentificationPayload, isChainIndexingServiceState, isChainIndexingServiceStateWithStorageMeta, isChainInformationPayload, isChainStakeIntent, isExecutable, isHashPayload, isNetworkStatus, isSigned, isSignedTransactionBoundWitness, isSignedTransactionBoundWitnessWithStorageMeta, isTransactionBoundWitness, isTransactionBoundWitnessWithStorageMeta, isTransfer, mXL1FromXL1, mXL1ToXL1, minTransactionFees };

package/dist/{neutral/index.mjs → index.js}

@@ -1,3 +1,13 @@
+// src/XL1.ts
+var XL1 = (value) => value;
+var MicroXL1 = (value) => value;
+var mXL1ToXL1 = (value) => {
+  return XL1(BigInt(value) / BigInt(1e6));
+};
+var mXL1FromXL1 = (value) => {
+  return MicroXL1(BigInt(value) * BigInt(1e6));
+};
+
 // src/block/AllowedBlockPayload.ts
 import { BoundWitnessSchema } from "@xyo-network/boundwitness-model";
 import { isHashStorageMeta, isSchema } from "@xyo-network/payload-model";
@@ -64,24 +74,7 @@ var asOptionalTransactionBoundWitness = AsObjectFactory4.createOptional(isTransa
 var asTransactionBoundWitnessWithStorageMeta = AsObjectFactory4.create(isTransactionBoundWitnessWithStorageMeta);
 var asOptionalTransactionBoundWitnessWithStorageMeta = AsObjectFactory4.createOptional(isTransactionBoundWitnessWithStorageMeta);
 
-// src/Xl1.ts
-var XL1 = (value) => value;
-var MicroXL1 = (value) => value;
-var mXl1ToXl1 = (value) => {
-  return XL1(BigInt(value) / BigInt(1e6));
-};
-var xl1ToMxl1 = (value) => {
-  return MicroXL1(BigInt(value) * BigInt(1e6));
-};
-
 // src/transaction/TransactionFeesFields.ts
-var TransactionGasCosts = {
-  byte: MicroXL1(10n),
-  payloadValidation: MicroXL1(1000n),
-  signatureValidation: MicroXL1(1000n),
-  hashValidation: MicroXL1(100n),
-  balanceValidation: MicroXL1(100n)
-};
 var minTransactionFees = {
   base: MicroXL1(1000n),
   gasPrice: MicroXL1(1n),
@@ -124,7 +117,27 @@ var asOptionalBlockBoundWitness = AsObjectFactory5.createOptional(isBlockBoundWi
 var asBlockBoundWitnessWithStorageMeta = AsObjectFactory5.create(isBlockBoundWitnessWithStorageMeta);
 var asOptionalBlockBoundWitnessWithStorageMeta = AsObjectFactory5.createOptional(isBlockBoundWitnessWithStorageMeta);
 
-// src/BlockNumber.ts
+// src/constants/StepSizes.ts
+var StepSizes = [10, 105, 1103, 11576, 121551, 1276282, 13400956];
+
+// src/constants/TransactionGasCosts.ts
+var TransactionGasCosts = {
+  /**
+   * The cost of storing each character that is added to the chain
+   * This includes the transaction JSON and all the elevated payloads' JSON
+  */
+  characterStorage: MicroXL1(10n),
+  /** The cost of static validating every payload that will be included in the chain */
+  payloadValidation: MicroXL1(1000n),
+  /** The cost of validating each signature that will be included in the chain */
+  signatureValidation: MicroXL1(1000n),
+  /** The cost of validating each hash that will be included in the chain */
+  hashValidation: MicroXL1(100n),
+  /** The cost of validating a balance state, triggered by a Transfer payload or gas collection */
+  balanceValidation: MicroXL1(100n)
+};
+
+// src/fields/BlockNumber.ts
 import { AsObjectFactory as AsObjectFactory6 } from "@xylabs/object";
 import {
   isPayloadOfSchemaType as isPayloadOfSchemaType4,
@@ -138,23 +151,6 @@ var isBlockNumberWithSources = isPayloadOfSchemaTypeWithSources(BlockNumberSchem
 var asBlockNumberWithSources = AsObjectFactory6.create(isBlockNumberWithSources);
 var asOptionalBlockNumberWithSources = AsObjectFactory6.createOptional(isBlockNumberWithSources);
 
-// src/ethereum.ts
-import { toHex } from "@xylabs/hex";
-import { getAddress } from "ethers";
-import { parseUnits } from "ethers/utils";
-var getDefaultGasConfig = () => {
-  return {
-    gasLimit: 2e6,
-    // Set the gas limit
-    gasPrice: parseUnits("100", "gwei")
-  };
-};
-var ETH_ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
-var toEthAddress = (value) => {
-  const address = typeof value === "object" ? value.address : value;
-  return getAddress(toHex(address, { prefix: true, bitLength: 160 }));
-};
-
 // src/network/Status.ts
 import { isPayloadOfSchemaType as isPayloadOfSchemaType5 } from "@xyo-network/payload-model";
 var NetworkStatusSchema = "network.xyo.chain.status";
@@ -181,9 +177,6 @@ var asChainIndexingServiceState = AsObjectFactory7.create(isChainIndexingService
 var isChainIndexingServiceStateWithStorageMeta = (value) => isChainIndexingServiceState(value) && isStorageMeta3(value);
 var asChainIndexingServiceStateWithStorageMeta = AsObjectFactory7.create(isChainIndexingServiceStateWithStorageMeta);
 var asOptionalChainIndexingServiceStateWithStorageMeta = AsObjectFactory7.createOptional(isChainIndexingServiceStateWithStorageMeta);
-
-// src/Steps.ts
-var StepSizes = [10, 105, 1103, 11576, 121551, 1276282, 13400956];
 export {
   AllowedBlockPayloadSchemas,
   BlockNumberSchema,
@@ -191,7 +184,6 @@ export {
   ChainIndexingServiceStateSchema,
   ChainInformationPayloadSchema,
   ChainStakeIntentSchema,
-  ETH_ZERO_ADDRESS,
   HashSchema,
   MicroXL1,
   NetworkStatusSchema,
@@ -223,7 +215,6 @@ export {
   asTransactionBoundWitnessWithStorageMeta,
   asTransfer,
   defaultTransactionFees,
-  getDefaultGasConfig,
   hasFrom,
   isAllowedBlockPayload,
   isAllowedBlockPayloadSchema,
@@ -246,9 +237,7 @@ export {
   isTransactionBoundWitness,
   isTransactionBoundWitnessWithStorageMeta,
   isTransfer,
-  mXl1ToXl1,
-  minTransactionFees,
-  toEthAddress,
-  xl1ToMxl1
+  mXL1FromXL1,
+  mXL1ToXL1,
+  minTransactionFees
 };
-//# sourceMappingURL=index.mjs.map