@xyo-network/xl1-sdk 4.0.10 → 4.0.12

package/dist/browser/modules/rpc/engine-node/middleware/createValidationMiddleware.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createValidationMiddleware.d.ts","sourceRoot":"","sources":["../../../../../../src/modules/rpc/engine-node/middleware/createValidationMiddleware.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAA;AAExD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAA;AAEpD;;;;;GAKG;AACH,eAAO,MAAM,0BAA0B,GAAI,SAAS,YAAY,KAAG,aAoBlE,CAAA"}

package/dist/browser/modules/rpc/engine-node/middleware/index.d.ts

@@ -0,0 +1,6 @@
+export * from './createHandlerMiddleware.js';
+export * from './createLoggingMiddleware.js';
+export * from './createMethodNotFoundMiddleware.js';
+export * from './createValidationMiddleware.js';
+export * from './RpcContext.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/browser/modules/rpc/engine-node/middleware/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/modules/rpc/engine-node/middleware/index.ts"],"names":[],"mappings":"AAAA,cAAc,8BAA8B,CAAA;AAC5C,cAAc,8BAA8B,CAAA;AAC5C,cAAc,qCAAqC,CAAA;AACnD,cAAc,iCAAiC,CAAA;AAC/C,cAAc,iBAAiB,CAAA"}

package/dist/browser/modules/rpc/engine-node/rpcEngineFromConnection.d.ts

@@ -0,0 +1,20 @@
+import type { Logger } from '@ariestools/sdk';
+import { JsonRpcEngineV2, JsonRpcServer } from '@metamask/json-rpc-engine/v2';
+import type { XyoConnection } from '@xyo-network/xl1-protocol/protocol-lib';
+/**
+ * @deprecated Use {@link composedRpcEngineFromConnection} instead. This original engine dispatches
+ * the entire `AllRpcSchemas` surface through a single generic middleware; the composed engine wires
+ * per-namespace typed sub-engines (validation + `TypedRpcHandlerRecord`) and is the migration target.
+ * Kept until consumers have moved over — see the parity spec.
+ */
+export declare const rpcEngineFromConnection: (connection: XyoConnection, logger?: Logger) => JsonRpcEngineV2<import("@metamask/json-rpc-engine/v2").JsonRpcCall, import("@metamask/json-rpc-engine/v2").MiddlewareContext<{
+    [x: string]: unknown;
+    [x: number]: unknown;
+    [x: symbol]: unknown;
+}>>;
+/**
+ * @deprecated Use {@link composedRpcServerFromConnection} instead. Wraps the deprecated
+ * {@link rpcEngineFromConnection}; superseded by the composed engine. Kept until consumers migrate.
+ */
+export declare function rpcServerFromConnection(connection: XyoConnection, logger?: Logger): JsonRpcServer<import("@metamask/json-rpc-engine/v2").JsonRpcMiddleware>;
+//# sourceMappingURL=rpcEngineFromConnection.d.ts.map

package/dist/browser/modules/rpc/engine-node/rpcEngineFromConnection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rpcEngineFromConnection.d.ts","sourceRoot":"","sources":["../../../../../src/modules/rpc/engine-node/rpcEngineFromConnection.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAA;AAC7C,OAAO,EAAE,eAAe,EAAE,aAAa,EAAE,MAAM,8BAA8B,CAAA;AAC7E,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,wCAAwC,CAAA;AAM3E;;;;;GAKG;AAEH,eAAO,MAAM,uBAAuB,GAClC,YAAY,aAAa,EACzB,SAAS,MAAM;;;;GAMhB,CAAA;AAED;;;GAGG;AACH,wBAAgB,uBAAuB,CAAC,UAAU,EAAE,aAAa,EAAE,MAAM,CAAC,EAAE,MAAM,2EAGjF"}

package/dist/browser/modules/rpc/index.d.ts

@@ -0,0 +1,3 @@
+export * from './client/index.js';
+export * from './server/index.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/browser/modules/rpc/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/modules/rpc/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAA;AACjC,cAAc,mBAAmB,CAAA"}

package/dist/browser/modules/rpc/provider/JsonRpcProvider.d.ts

@@ -0,0 +1,41 @@
+import type { EventData } from '@ariestools/sdk';
+import type { CreatableProviderEventData, CreatableProviderParams } from '../../protocol-sdk/index.js';
+import { AbstractCreatableProvider } from '../../protocol-sdk/index.js';
+import type { RpcTransport } from '../transport/index.js';
+import type { RpcSchemaMap } from '../types/index.js';
+/**
+ * Transport wiring shared by every JsonRpc provider.
+ *
+ * A provider always owns its `schemas()` — callers must never supply schemas.
+ * To point a provider at a specific endpoint, inject `rpcUrl` (the provider
+ * still wires its own schemas), not a pre-built `transport`. Injecting a
+ * fully-formed transport is supported for advanced/test scenarios, in which
+ * case the caller owns that transport's schemas.
+ */
+export interface RpcTransportParams<TSchemas extends RpcSchemaMap = RpcSchemaMap> {
+    /** Explicit RPC endpoint URL. The provider supplies its own schemas. */
+    rpcUrl?: string;
+    /** A fully-constructed transport. Takes precedence over `rpcUrl` and connection discovery. */
+    transport?: RpcTransport<TSchemas>;
+}
+/** Parameters shared by all JsonRpc providers (viewers and runners). */
+export interface JsonRpcProviderParams<TSchemas extends RpcSchemaMap = RpcSchemaMap> extends CreatableProviderParams, RpcTransportParams<TSchemas> {
+}
+/**
+ * Abstract base for JsonRpc providers (viewers and runners).
+ *
+ * Owns the transport lifecycle so the two surfaces cannot drift. `schemas()`
+ * always comes from the provider itself, so neither an injected `rpcUrl` nor a
+ * discovered connection can strip a method's schema — the cause of "missing
+ * schema" failures (and silently skipped result decoding) when a schema-less
+ * transport was injected by a layer that knew only the endpoint.
+ *
+ * Precedence: an explicitly injected `transport` › `rpcUrl` › connection discovery.
+ */
+export declare abstract class AbstractJsonRpcProvider<TSchemas extends RpcSchemaMap, TParams extends JsonRpcProviderParams<TSchemas> = JsonRpcProviderParams<TSchemas>, TEventData extends EventData = CreatableProviderEventData> extends AbstractCreatableProvider<TParams, TEventData> {
+    protected get transport(): RpcTransport<TSchemas>;
+    createHandler(): Promise<void>;
+    protected createTransport(): RpcTransport<TSchemas>;
+    protected abstract schemas(): TSchemas;
+}
+//# sourceMappingURL=JsonRpcProvider.d.ts.map

package/dist/browser/modules/rpc/provider/JsonRpcProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"JsonRpcProvider.d.ts","sourceRoot":"","sources":["../../../../../src/modules/rpc/provider/JsonRpcProvider.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAGhD,OAAO,KAAK,EACV,0BAA0B,EAAE,uBAAuB,EACpD,MAAM,eAAe,CAAA;AACtB,OAAO,EAAE,yBAAyB,EAAE,MAAM,eAAe,CAAA;AAEzD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAA;AAEzD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAA;AAErD;;;;;;;;GAQG;AACH,MAAM,WAAW,kBAAkB,CAAC,QAAQ,SAAS,YAAY,GAAG,YAAY;IAC9E,wEAAwE;IACxE,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,8FAA8F;IAC9F,SAAS,CAAC,EAAE,YAAY,CAAC,QAAQ,CAAC,CAAA;CACnC;AAED,wEAAwE;AACxE,MAAM,WAAW,qBAAqB,CAAC,QAAQ,SAAS,YAAY,GAAG,YAAY,CACjF,SAAQ,uBAAuB,EAAE,kBAAkB,CAAC,QAAQ,CAAC;CAAG;AAWlE;;;;;;;;;;GAUG;AACH,8BAAsB,uBAAuB,CAC3C,QAAQ,SAAS,YAAY,EAC7B,OAAO,SAAS,qBAAqB,CAAC,QAAQ,CAAC,GAAG,qBAAqB,CAAC,QAAQ,CAAC,EACjF,UAAU,SAAS,SAAS,GAAG,0BAA0B,CACzD,SAAQ,yBAAyB,CAAC,OAAO,EAAE,UAAU,CAAC;IACtD,SAAS,KAAK,SAAS,2BAEtB;IAEc,aAAa;IAK5B,SAAS,CAAC,eAAe,IAAI,YAAY,CAAC,QAAQ,CAAC;IAmBnD,SAAS,CAAC,QAAQ,CAAC,OAAO,IAAI,QAAQ;CACvC"}

package/dist/browser/modules/rpc/provider/datalake/JsonRpcDataLakeViewer.d.ts

@@ -0,0 +1,7 @@
+import type { DataLakeViewer } from '@xyo-network/xl1-protocol/protocol-lib';
+import { JsonRpcDataLakeViewerMethods } from './JsonRpcDataLakeViewerMethods.js';
+/** JsonRpcDataLakeViewer implementation. */
+export declare class JsonRpcDataLakeViewer extends JsonRpcDataLakeViewerMethods implements DataLakeViewer {
+    static readonly dependencies: never[];
+}
+//# sourceMappingURL=JsonRpcDataLakeViewer.d.ts.map

package/dist/browser/modules/rpc/provider/datalake/JsonRpcDataLakeViewer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"JsonRpcDataLakeViewer.d.ts","sourceRoot":"","sources":["../../../../../../src/modules/rpc/provider/datalake/JsonRpcDataLakeViewer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wCAAwC,CAAA;AAI5E,OAAO,EAAE,4BAA4B,EAAE,MAAM,mCAAmC,CAAA;AAEhF,4CAA4C;AAC5C,qBACa,qBAAsB,SAAQ,4BAA6B,YAAW,cAAc;IAC/F,MAAM,CAAC,QAAQ,CAAC,YAAY,UAAK;CAClC"}

package/dist/browser/modules/rpc/provider/datalake/JsonRpcDataLakeViewerMethods.d.ts

@@ -0,0 +1,44 @@
+import type { Hash, PromisableArray } from '@ariestools/sdk';
+import type { NextOptions, Sequence } from '@xyo-network/sdk';
+import type { DataLakeData, DataLakeViewerMethods } from '@xyo-network/xl1-protocol/protocol-lib';
+import { DataLakeViewerRpcSchemas } from '../../types/index.js';
+import { AbstractJsonRpcViewer } from '../viewer/index.js';
+/** JsonRpcDataLakeViewerMethods implementation. */
+export declare class JsonRpcDataLakeViewerMethods extends AbstractJsonRpcViewer<DataLakeViewerRpcSchemas> implements DataLakeViewerMethods {
+    static readonly defaultMoniker: "DataLakeViewer";
+    static readonly monikers: "DataLakeViewer"[];
+    moniker: "DataLakeViewer";
+    get(_hashes: Hash[]): PromisableArray<DataLakeData>;
+    next(_options?: NextOptions<Sequence>): PromisableArray<DataLakeData>;
+    protected schemas(): {
+        dataLakeViewer_get: {
+            params: {
+                to: import("zod/mini").ZodMiniTuple<readonly [import("zod/mini").ZodMiniArray<import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>>], null>;
+                from: import("zod/mini").ZodMiniTuple<readonly [import("zod/mini").ZodMiniArray<import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>>], null>;
+            };
+            result: {
+                to: import("zod/mini").ZodMiniArray<import("zod/mini").ZodMiniUnion<readonly [import("zod/mini").ZodMiniObject<{
+                    schema: import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@xyo-network/sdk").BrandedSchema<string>, string>>;
+                }, import("zod/v4/core").$loose>, import("zod").ZodPipe<import("zod").ZodCustom<ArrayBuffer, ArrayBuffer>, import("zod").ZodTransform<string, ArrayBuffer>>]>>;
+                from: import("zod/mini").ZodMiniArray<import("zod/mini").ZodMiniUnion<readonly [import("zod/mini").ZodMiniObject<{
+                    schema: import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@xyo-network/sdk").BrandedSchema<string>, string>>;
+                }, import("zod/v4/core").$loose>, import("zod").ZodPipe<import("zod").ZodString, import("zod").ZodTransform<ArrayBuffer | SharedArrayBuffer, string>>]>>;
+            };
+        };
+        dataLakeViewer_next: {
+            params: {
+                to: import("zod/mini").ZodMiniTuple<readonly [import("zod/mini").ZodMiniObject<{}, import("zod/v4/core").$loose>], null>;
+                from: import("zod/mini").ZodMiniTuple<readonly [import("zod/mini").ZodMiniObject<{}, import("zod/v4/core").$loose>], null>;
+            };
+            result: {
+                to: import("zod/mini").ZodMiniArray<import("zod/mini").ZodMiniUnion<readonly [import("zod/mini").ZodMiniObject<{
+                    schema: import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@xyo-network/sdk").BrandedSchema<string>, string>>;
+                }, import("zod/v4/core").$loose>, import("zod").ZodPipe<import("zod").ZodCustom<ArrayBuffer, ArrayBuffer>, import("zod").ZodTransform<string, ArrayBuffer>>]>>;
+                from: import("zod/mini").ZodMiniArray<import("zod/mini").ZodMiniUnion<readonly [import("zod/mini").ZodMiniObject<{
+                    schema: import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@xyo-network/sdk").BrandedSchema<string>, string>>;
+                }, import("zod/v4/core").$loose>, import("zod").ZodPipe<import("zod").ZodString, import("zod").ZodTransform<ArrayBuffer | SharedArrayBuffer, string>>]>>;
+            };
+        };
+    };
+}
+//# sourceMappingURL=JsonRpcDataLakeViewerMethods.d.ts.map

package/dist/browser/modules/rpc/provider/datalake/JsonRpcDataLakeViewerMethods.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"JsonRpcDataLakeViewerMethods.d.ts","sourceRoot":"","sources":["../../../../../../src/modules/rpc/provider/datalake/JsonRpcDataLakeViewerMethods.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAA;AAC5D,OAAO,KAAK,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAA;AAC7D,OAAO,KAAK,EAAE,YAAY,EAAE,qBAAqB,EAAE,MAAM,wCAAwC,CAAA;AAGjG,OAAO,EAAE,wBAAwB,EAAE,MAAM,sBAAsB,CAAA;AAC/D,OAAO,EAAE,qBAAqB,EAAE,MAAM,oBAAoB,CAAA;AAE1D,mDAAmD;AACnD,qBAAa,4BAA6B,SAAQ,qBAAqB,CAAC,wBAAwB,CAAE,YAAW,qBAAqB;IAChI,MAAM,CAAC,QAAQ,CAAC,cAAc,mBAAwB;IACtD,MAAM,CAAC,QAAQ,CAAC,QAAQ,qBAA0B;IAClD,OAAO,mBAA8C;IAErD,GAAG,CAAC,OAAO,EAAE,IAAI,EAAE,GAAG,eAAe,CAAC,YAAY,CAAC;IAInD,IAAI,CAAC,QAAQ,CAAC,EAAE,WAAW,CAAC,QAAQ,CAAC,GAAG,eAAe,CAAC,YAAY,CAAC;IAIrE,SAAS,CAAC,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAGlB"}

package/dist/browser/modules/rpc/provider/datalake/index.d.ts

@@ -0,0 +1,3 @@
+export * from './JsonRpcDataLakeViewer.js';
+export * from './JsonRpcDataLakeViewerMethods.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/browser/modules/rpc/provider/datalake/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/modules/rpc/provider/datalake/index.ts"],"names":[],"mappings":"AAAA,cAAc,4BAA4B,CAAA;AAC1C,cAAc,mCAAmC,CAAA"}

package/dist/browser/modules/rpc/provider/index.d.ts

@@ -0,0 +1,7 @@
+export * from './datalake/index.js';
+export * from './JsonRpcProvider.js';
+export * from './permissions/index.js';
+export * from './runner/index.js';
+export * from './signer/index.js';
+export * from './viewer/index.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/browser/modules/rpc/provider/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/modules/rpc/provider/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAA;AACnC,cAAc,sBAAsB,CAAA;AACpC,cAAc,wBAAwB,CAAA;AACtC,cAAc,mBAAmB,CAAA;AACjC,cAAc,mBAAmB,CAAA;AACjC,cAAc,mBAAmB,CAAA"}

package/dist/browser/modules/rpc/provider/permissions/RpcXyoPermissions.d.ts

@@ -0,0 +1,12 @@
+import type { InvokerPermission, PermissionRequest, RequestedPermission, XyoPermissions } from '@xyo-network/xl1-protocol/protocol-lib';
+import type { RpcTransport } from '../../transport/index.js';
+import type { XyoPermissionsRpcSchemas } from '../../types/index.js';
+/** RpcXyoPermissions implementation. */
+export declare class RpcXyoPermissions implements XyoPermissions {
+    protected readonly transport: RpcTransport<typeof XyoPermissionsRpcSchemas>;
+    constructor(transport: RpcTransport<typeof XyoPermissionsRpcSchemas>);
+    getPermissions(): Promise<InvokerPermission[]>;
+    requestPermissions(permissions: PermissionRequest[]): Promise<RequestedPermission[]>;
+    revokePermissions(_permissions: PermissionRequest): Promise<RequestedPermission[]>;
+}
+//# sourceMappingURL=RpcXyoPermissions.d.ts.map

package/dist/browser/modules/rpc/provider/permissions/RpcXyoPermissions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RpcXyoPermissions.d.ts","sourceRoot":"","sources":["../../../../../../src/modules/rpc/provider/permissions/RpcXyoPermissions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,iBAAiB,EACjB,iBAAiB,EACjB,mBAAmB,EACnB,cAAc,EACf,MAAM,wCAAwC,CAAA;AAE/C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAA;AAC5D,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,sBAAsB,CAAA;AAEpE,wCAAwC;AACxC,qBAAa,iBAAkB,YAAW,cAAc;IACtD,SAAS,CAAC,QAAQ,CAAC,SAAS,EAAE,YAAY,CAAC,OAAO,wBAAwB,CAAC,CAAA;gBAE/D,SAAS,EAAE,YAAY,CAAC,OAAO,wBAAwB,CAAC;IAI9D,cAAc,IAAI,OAAO,CAAC,iBAAiB,EAAE,CAAC;IAI9C,kBAAkB,CAAC,WAAW,EAAE,iBAAiB,EAAE,GAAG,OAAO,CAAC,mBAAmB,EAAE,CAAC;IAIpF,iBAAiB,CAAC,YAAY,EAAE,iBAAiB,GAAG,OAAO,CAAC,mBAAmB,EAAE,CAAC;CAIzF"}

package/dist/browser/modules/rpc/provider/permissions/index.d.ts

@@ -0,0 +1,2 @@
+export * from './RpcXyoPermissions.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/browser/modules/rpc/provider/permissions/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/modules/rpc/provider/permissions/index.ts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAA"}

package/dist/browser/modules/rpc/provider/runner/JsonRpcMempoolRunner/JsonRpcMempoolRunner.d.ts

@@ -0,0 +1,13 @@
+import type { MempoolPruneOptions, MempoolRunner } from '@xyo-network/xl1-protocol/protocol-lib';
+import { JsonRpcMempoolRunnerMethods } from './JsonRpcMempoolRunnerMethods.js';
+/** JsonRpcMempoolRunner implementation. */
+export declare class JsonRpcMempoolRunner extends JsonRpcMempoolRunnerMethods implements MempoolRunner {
+    static readonly connectionTypes: readonly ["rpc"];
+    static readonly defaultMoniker: "MempoolRunner";
+    static readonly dependencies: never[];
+    static readonly monikers: "MempoolRunner"[];
+    static readonly surface: "node";
+    prunePendingBlocks(_options?: MempoolPruneOptions): Promise<[number, number]>;
+    prunePendingTransactions(_options?: MempoolPruneOptions): Promise<[number, number]>;
+}
+//# sourceMappingURL=JsonRpcMempoolRunner.d.ts.map

package/dist/browser/modules/rpc/provider/runner/JsonRpcMempoolRunner/JsonRpcMempoolRunner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"JsonRpcMempoolRunner.d.ts","sourceRoot":"","sources":["../../../../../../../src/modules/rpc/provider/runner/JsonRpcMempoolRunner/JsonRpcMempoolRunner.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,aAAa,EAAE,MAAM,wCAAwC,CAAA;AAKhG,OAAO,EAAE,2BAA2B,EAAE,MAAM,kCAAkC,CAAA;AAE9E,2CAA2C;AAC3C,qBACa,oBAAqB,SAAQ,2BAA4B,YAAW,aAAa;IAC5F,MAAM,CAAC,QAAQ,CAAC,eAAe,mBAAmB;IAClD,MAAM,CAAC,QAAQ,CAAC,cAAc,kBAAuB;IACrD,MAAM,CAAC,QAAQ,CAAC,YAAY,UAAK;IACjC,MAAM,CAAC,QAAQ,CAAC,QAAQ,oBAAyB;IACjD,MAAM,CAAC,QAAQ,CAAC,OAAO,EAAG,MAAM,CAAS;IAEzC,kBAAkB,CAAC,QAAQ,CAAC,EAAE,mBAAmB,GAAG,OAAO,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAI7E,wBAAwB,CAAC,QAAQ,CAAC,EAAE,mBAAmB,GAAG,OAAO,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAGpF"}

package/dist/browser/modules/rpc/provider/runner/JsonRpcMempoolRunner/JsonRpcMempoolRunnerMethods.d.ts

@@ -0,0 +1,159 @@
+import type { Hash } from '@ariestools/sdk';
+import type { MempoolRunnerMethods, SignedHydratedBlock, SignedHydratedTransaction } from '@xyo-network/xl1-protocol/protocol-lib';
+import { MempoolRunnerRpcSchemas } from '../../../types/index.js';
+import { AbstractJsonRpcRunner } from '../JsonRpcRunner.js';
+/** JsonRpcMempoolRunnerMethods implementation. */
+export declare class JsonRpcMempoolRunnerMethods extends AbstractJsonRpcRunner<typeof MempoolRunnerRpcSchemas> implements MempoolRunnerMethods {
+    readonly moniker: "MempoolRunner";
+    submitBlocks(blocks: SignedHydratedBlock[]): Promise<Hash[]>;
+    submitTransactions(transactions: SignedHydratedTransaction[]): Promise<Hash[]>;
+    protected schemas(): {
+        mempoolRunner_submitBlocks: {
+            params: {
+                to: import("zod").ZodTuple<[import("zod").ZodArray<import("zod/mini").ZodMiniTuple<readonly [import("zod/mini").ZodMiniObject<{
+                    schema: import("zod/mini").ZodMiniLiteral<"network.xyo.boundwitness" & {
+                        readonly __schema: true;
+                    }>;
+                    addresses: import("zod/mini").ZodMiniArray<import("zod/mini").ZodMiniUnion<readonly [import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<Lowercase<string> & {
+                        readonly __hex: true;
+                    } & {
+                        readonly __address: true;
+                    }, string>>, import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@xyo-network/sdk").XyoQuantAddress, string>>]>>;
+                    payload_hashes: import("zod/mini").ZodMiniArray<import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>>;
+                    payload_schemas: import("zod/mini").ZodMiniArray<import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@xyo-network/sdk").BrandedSchema<string>, string>>>;
+                    previous_hashes: import("zod/mini").ZodMiniArray<import("zod/mini").ZodMiniNullable<import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>>>;
+                    $destination: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniUnion<readonly [import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<Lowercase<string> & {
+                        readonly __hex: true;
+                    } & {
+                        readonly __address: true;
+                    }, string>>, import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@xyo-network/sdk").XyoQuantAddress, string>>]>>;
+                    $sourceQuery: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>>;
+                    $signatures: import("zod/mini").ZodMiniArray<import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHex, string>>>;
+                    block: import("zod").ZodPipe<import("zod").ZodInt, import("zod").ZodTransform<import("@xyo-network/xl1-protocol/protocol-lib").XL1BlockNumber, number>>;
+                    chain: import("zod").ZodPipe<import("zod").ZodString, import("zod").ZodTransform<import("@ariestools/sdk").BrandedHex, string>>;
+                    previous: import("zod/mini").ZodMiniNullable<import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>>;
+                    protocol: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniNumber<number>>;
+                    step_hashes: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniArray<import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>>>;
+                    $epoch: import("zod/mini").ZodMiniNumber<number>;
+                }, import("zod/v4/core").$strip>, import("zod/mini").ZodMiniArray<import("zod/mini").ZodMiniObject<{
+                    schema: import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@xyo-network/sdk").BrandedSchema<string>, string>>;
+                }, import("zod/v4/core").$loose>>], null>>], null>;
+                from: import("zod").ZodTuple<[import("zod").ZodArray<import("zod/mini").ZodMiniTuple<readonly [import("zod/mini").ZodMiniObject<{
+                    schema: import("zod/mini").ZodMiniLiteral<"network.xyo.boundwitness" & {
+                        readonly __schema: true;
+                    }>;
+                    addresses: import("zod/mini").ZodMiniArray<import("zod/mini").ZodMiniUnion<readonly [import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<Lowercase<string> & {
+                        readonly __hex: true;
+                    } & {
+                        readonly __address: true;
+                    }, string>>, import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@xyo-network/sdk").XyoQuantAddress, string>>]>>;
+                    payload_hashes: import("zod/mini").ZodMiniArray<import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>>;
+                    payload_schemas: import("zod/mini").ZodMiniArray<import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@xyo-network/sdk").BrandedSchema<string>, string>>>;
+                    previous_hashes: import("zod/mini").ZodMiniArray<import("zod/mini").ZodMiniNullable<import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>>>;
+                    $destination: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniUnion<readonly [import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<Lowercase<string> & {
+                        readonly __hex: true;
+                    } & {
+                        readonly __address: true;
+                    }, string>>, import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@xyo-network/sdk").XyoQuantAddress, string>>]>>;
+                    $sourceQuery: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>>;
+                    $signatures: import("zod/mini").ZodMiniArray<import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHex, string>>>;
+                    block: import("zod").ZodPipe<import("zod").ZodInt, import("zod").ZodTransform<import("@xyo-network/xl1-protocol/protocol-lib").XL1BlockNumber, number>>;
+                    chain: import("zod").ZodPipe<import("zod").ZodString, import("zod").ZodTransform<import("@ariestools/sdk").BrandedHex, string>>;
+                    previous: import("zod/mini").ZodMiniNullable<import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>>;
+                    protocol: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniNumber<number>>;
+                    step_hashes: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniArray<import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>>>;
+                    $epoch: import("zod/mini").ZodMiniNumber<number>;
+                }, import("zod/v4/core").$strip>, import("zod/mini").ZodMiniArray<import("zod/mini").ZodMiniObject<{
+                    schema: import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@xyo-network/sdk").BrandedSchema<string>, string>>;
+                }, import("zod/v4/core").$loose>>], null>>], null>;
+            };
+            result: {
+                to: import("zod").ZodArray<import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>>;
+                from: import("zod").ZodArray<import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>>;
+            };
+        };
+        mempoolRunner_submitTransactions: {
+            params: {
+                to: import("zod").ZodTuple<[import("zod").ZodArray<import("zod/mini").ZodMiniTuple<readonly [import("zod/mini").ZodMiniObject<{
+                    schema: import("zod/mini").ZodMiniLiteral<"network.xyo.boundwitness" & {
+                        readonly __schema: true;
+                    }>;
+                    addresses: import("zod/mini").ZodMiniArray<import("zod/mini").ZodMiniUnion<readonly [import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<Lowercase<string> & {
+                        readonly __hex: true;
+                    } & {
+                        readonly __address: true;
+                    }, string>>, import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@xyo-network/sdk").XyoQuantAddress, string>>]>>;
+                    payload_hashes: import("zod/mini").ZodMiniArray<import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>>;
+                    payload_schemas: import("zod/mini").ZodMiniArray<import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@xyo-network/sdk").BrandedSchema<string>, string>>>;
+                    previous_hashes: import("zod/mini").ZodMiniArray<import("zod/mini").ZodMiniNullable<import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>>>;
+                    $destination: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniUnion<readonly [import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<Lowercase<string> & {
+                        readonly __hex: true;
+                    } & {
+                        readonly __address: true;
+                    }, string>>, import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@xyo-network/sdk").XyoQuantAddress, string>>]>>;
+                    $sourceQuery: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>>;
+                    $signatures: import("zod/mini").ZodMiniArray<import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHex, string>>>;
+                    nbf: import("zod").ZodPipe<import("zod").ZodInt, import("zod").ZodTransform<import("@xyo-network/xl1-protocol/protocol-lib").XL1BlockNumber, number>>;
+                    exp: import("zod").ZodPipe<import("zod").ZodInt, import("zod").ZodTransform<import("@xyo-network/xl1-protocol/protocol-lib").XL1BlockNumber, number>>;
+                    fees: import("zod/mini").ZodMiniObject<{
+                        base: import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHex, string>>;
+                        gasLimit: import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHex, string>>;
+                        gasPrice: import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHex, string>>;
+                        priority: import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHex, string>>;
+                    }, import("zod/v4/core").$strip>;
+                    chain: import("zod").ZodPipe<import("zod").ZodString, import("zod").ZodTransform<import("@ariestools/sdk").BrandedHex, string>>;
+                    from: import("zod/mini").ZodMiniUnion<readonly [import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<Lowercase<string> & {
+                        readonly __hex: true;
+                    } & {
+                        readonly __address: true;
+                    }, string>>, import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@xyo-network/sdk").XyoQuantAddress, string>>]>;
+                    script: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniArray<import("zod/mini").ZodMiniString<string>>>;
+                }, import("zod/v4/core").$strip>, import("zod/mini").ZodMiniArray<import("zod/mini").ZodMiniObject<{
+                    schema: import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@xyo-network/sdk").BrandedSchema<string>, string>>;
+                }, import("zod/v4/core").$strict>>], null>>], null>;
+                from: import("zod").ZodTuple<[import("zod").ZodArray<import("zod/mini").ZodMiniTuple<readonly [import("zod/mini").ZodMiniObject<{
+                    schema: import("zod/mini").ZodMiniLiteral<"network.xyo.boundwitness" & {
+                        readonly __schema: true;
+                    }>;
+                    addresses: import("zod/mini").ZodMiniArray<import("zod/mini").ZodMiniUnion<readonly [import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<Lowercase<string> & {
+                        readonly __hex: true;
+                    } & {
+                        readonly __address: true;
+                    }, string>>, import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@xyo-network/sdk").XyoQuantAddress, string>>]>>;
+                    payload_hashes: import("zod/mini").ZodMiniArray<import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>>;
+                    payload_schemas: import("zod/mini").ZodMiniArray<import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@xyo-network/sdk").BrandedSchema<string>, string>>>;
+                    previous_hashes: import("zod/mini").ZodMiniArray<import("zod/mini").ZodMiniNullable<import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>>>;
+                    $destination: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniUnion<readonly [import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<Lowercase<string> & {
+                        readonly __hex: true;
+                    } & {
+                        readonly __address: true;
+                    }, string>>, import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@xyo-network/sdk").XyoQuantAddress, string>>]>>;
+                    $sourceQuery: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>>;
+                    $signatures: import("zod/mini").ZodMiniArray<import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHex, string>>>;
+                    nbf: import("zod").ZodPipe<import("zod").ZodInt, import("zod").ZodTransform<import("@xyo-network/xl1-protocol/protocol-lib").XL1BlockNumber, number>>;
+                    exp: import("zod").ZodPipe<import("zod").ZodInt, import("zod").ZodTransform<import("@xyo-network/xl1-protocol/protocol-lib").XL1BlockNumber, number>>;
+                    fees: import("zod/mini").ZodMiniObject<{
+                        base: import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHex, string>>;
+                        gasLimit: import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHex, string>>;
+                        gasPrice: import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHex, string>>;
+                        priority: import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHex, string>>;
+                    }, import("zod/v4/core").$strip>;
+                    chain: import("zod").ZodPipe<import("zod").ZodString, import("zod").ZodTransform<import("@ariestools/sdk").BrandedHex, string>>;
+                    from: import("zod/mini").ZodMiniUnion<readonly [import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<Lowercase<string> & {
+                        readonly __hex: true;
+                    } & {
+                        readonly __address: true;
+                    }, string>>, import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@xyo-network/sdk").XyoQuantAddress, string>>]>;
+                    script: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniArray<import("zod/mini").ZodMiniString<string>>>;
+                }, import("zod/v4/core").$strip>, import("zod/mini").ZodMiniArray<import("zod/mini").ZodMiniObject<{
+                    schema: import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@xyo-network/sdk").BrandedSchema<string>, string>>;
+                }, import("zod/v4/core").$strict>>], null>>], null>;
+            };
+            result: {
+                to: import("zod").ZodArray<import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>>;
+                from: import("zod").ZodArray<import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>>;
+            };
+        };
+    };
+}
+//# sourceMappingURL=JsonRpcMempoolRunnerMethods.d.ts.map

package/dist/browser/modules/rpc/provider/runner/JsonRpcMempoolRunner/JsonRpcMempoolRunnerMethods.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"JsonRpcMempoolRunnerMethods.d.ts","sourceRoot":"","sources":["../../../../../../../src/modules/rpc/provider/runner/JsonRpcMempoolRunner/JsonRpcMempoolRunnerMethods.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAA;AAE3C,OAAO,KAAK,EACV,oBAAoB,EAAE,mBAAmB,EAAE,yBAAyB,EACrE,MAAM,wCAAwC,CAAA;AAG/C,OAAO,EAAE,uBAAuB,EAAE,MAAM,yBAAyB,CAAA;AACjE,OAAO,EAAE,qBAAqB,EAAE,MAAM,qBAAqB,CAAA;AAE3D,kDAAkD;AAClD,qBAAa,2BAA4B,SAAQ,qBAAqB,CAAC,OAAO,uBAAuB,CAAE,YAAW,oBAAoB;IACpI,QAAQ,CAAC,OAAO,kBAAuB;IACjC,YAAY,CAAC,MAAM,EAAE,mBAAmB,EAAE,GAAG,OAAO,CAAC,IAAI,EAAE,CAAC;IAQ5D,kBAAkB,CAAC,YAAY,EAAE,yBAAyB,EAAE,GAAG,OAAO,CAAC,IAAI,EAAE,CAAC;IAgBpF,SAAS,CAAC,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAGlB"}

package/dist/browser/modules/rpc/provider/runner/JsonRpcMempoolRunner/index.d.ts

@@ -0,0 +1,3 @@
+export * from './JsonRpcMempoolRunner.js';
+export * from './JsonRpcMempoolRunnerMethods.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/browser/modules/rpc/provider/runner/JsonRpcMempoolRunner/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../src/modules/rpc/provider/runner/JsonRpcMempoolRunner/index.ts"],"names":[],"mappings":"AAAA,cAAc,2BAA2B,CAAA;AACzC,cAAc,kCAAkC,CAAA"}

package/dist/browser/modules/rpc/provider/runner/JsonRpcRunner.d.ts

@@ -0,0 +1,11 @@
+import type { EventData } from '@ariestools/sdk';
+import type { CreatableProviderEventData } from '../../../protocol-sdk/index.js';
+import type { RpcSchemaMap } from '../../types/index.js';
+import { AbstractJsonRpcProvider, type JsonRpcProviderParams } from '../JsonRpcProvider.js';
+/** Parameters for JsonRpcRunner. */
+export interface JsonRpcRunnerParams<TSchemas extends RpcSchemaMap = RpcSchemaMap> extends JsonRpcProviderParams<TSchemas> {
+}
+/** Abstract base class for JsonRpcRunner implementations. */
+export declare abstract class AbstractJsonRpcRunner<TSchemas extends RpcSchemaMap, TParams extends JsonRpcRunnerParams<TSchemas> = JsonRpcRunnerParams<TSchemas>, TEventData extends EventData = CreatableProviderEventData> extends AbstractJsonRpcProvider<TSchemas, TParams, TEventData> {
+}
+//# sourceMappingURL=JsonRpcRunner.d.ts.map

package/dist/browser/modules/rpc/provider/runner/JsonRpcRunner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"JsonRpcRunner.d.ts","sourceRoot":"","sources":["../../../../../../src/modules/rpc/provider/runner/JsonRpcRunner.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAEhD,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,eAAe,CAAA;AAE/D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAA;AACxD,OAAO,EAAE,uBAAuB,EAAE,KAAK,qBAAqB,EAAE,MAAM,uBAAuB,CAAA;AAE3F,oCAAoC;AACpC,MAAM,WAAW,mBAAmB,CAAC,QAAQ,SAAS,YAAY,GAAG,YAAY,CAC/E,SAAQ,qBAAqB,CAAC,QAAQ,CAAC;CAAG;AAE5C,6DAA6D;AAC7D,8BAAsB,qBAAqB,CAAC,QAAQ,SAAS,YAAY,EACvE,OAAO,SAAS,mBAAmB,CAAC,QAAQ,CAAC,GAAG,mBAAmB,CAAC,QAAQ,CAAC,EAC7E,UAAU,SAAS,SAAS,GAAG,0BAA0B,CAAE,SAAQ,uBAAuB,CAAC,QAAQ,EAAE,OAAO,EAAE,UAAU,CAAC;CAAG"}

package/dist/browser/modules/rpc/provider/runner/JsonRpcXyoRunner.d.ts

@@ -0,0 +1,102 @@
+import { type Hash } from '@ariestools/sdk';
+import type { MempoolRunner, SignedHydratedTransaction, XyoRunner } from '@xyo-network/xl1-protocol/protocol-lib';
+import { XyoRunnerRpcSchemas } from '../../types/index.js';
+import { AbstractJsonRpcRunner } from './JsonRpcRunner.js';
+/** JsonRpcXyoRunner implementation. */
+export declare class JsonRpcXyoRunner extends AbstractJsonRpcRunner<XyoRunnerRpcSchemas> implements XyoRunner {
+    static readonly connectionTypes: readonly ["rpc"];
+    static readonly defaultMoniker: "XyoRunner";
+    static readonly dependencies: "MempoolRunner"[];
+    static readonly monikers: "XyoRunner"[];
+    static readonly surface: "node";
+    moniker: "XyoRunner";
+    private _mempoolRunner?;
+    get mempool(): MempoolRunner;
+    broadcastTransaction(transaction: SignedHydratedTransaction): Promise<Hash>;
+    createHandler(): Promise<void>;
+    protected schemas(): {
+        xyoRunner_broadcastTransaction: {
+            params: {
+                to: import("zod").ZodTuple<[import("zod/mini").ZodMiniTuple<readonly [import("zod/mini").ZodMiniObject<{
+                    schema: import("zod/mini").ZodMiniLiteral<"network.xyo.boundwitness" & {
+                        readonly __schema: true;
+                    }>;
+                    addresses: import("zod/mini").ZodMiniArray<import("zod/mini").ZodMiniUnion<readonly [import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<Lowercase<string> & {
+                        readonly __hex: true;
+                    } & {
+                        readonly __address: true;
+                    }, string>>, import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@xyo-network/sdk-protocol").XyoQuantAddress, string>>]>>;
+                    payload_hashes: import("zod/mini").ZodMiniArray<import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>>;
+                    payload_schemas: import("zod/mini").ZodMiniArray<import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@xyo-network/sdk-protocol").BrandedSchema<string>, string>>>;
+                    previous_hashes: import("zod/mini").ZodMiniArray<import("zod/mini").ZodMiniNullable<import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>>>;
+                    $destination: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniUnion<readonly [import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<Lowercase<string> & {
+                        readonly __hex: true;
+                    } & {
+                        readonly __address: true;
+                    }, string>>, import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@xyo-network/sdk-protocol").XyoQuantAddress, string>>]>>;
+                    $sourceQuery: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>>;
+                    $signatures: import("zod/mini").ZodMiniArray<import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHex, string>>>;
+                    nbf: import("zod").ZodPipe<import("zod").ZodInt, import("zod").ZodTransform<import("@xyo-network/xl1-protocol/protocol-lib").XL1BlockNumber, number>>;
+                    exp: import("zod").ZodPipe<import("zod").ZodInt, import("zod").ZodTransform<import("@xyo-network/xl1-protocol/protocol-lib").XL1BlockNumber, number>>;
+                    fees: import("zod/mini").ZodMiniObject<{
+                        base: import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHex, string>>;
+                        gasLimit: import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHex, string>>;
+                        gasPrice: import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHex, string>>;
+                        priority: import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHex, string>>;
+                    }, import("zod/v4/core").$strip>;
+                    chain: import("zod").ZodPipe<import("zod").ZodString, import("zod").ZodTransform<import("@ariestools/sdk").BrandedHex, string>>;
+                    from: import("zod/mini").ZodMiniUnion<readonly [import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<Lowercase<string> & {
+                        readonly __hex: true;
+                    } & {
+                        readonly __address: true;
+                    }, string>>, import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@xyo-network/sdk-protocol").XyoQuantAddress, string>>]>;
+                    script: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniArray<import("zod/mini").ZodMiniString<string>>>;
+                }, import("zod/v4/core").$strip>, import("zod/mini").ZodMiniArray<import("zod/mini").ZodMiniObject<{
+                    schema: import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@xyo-network/sdk-protocol").BrandedSchema<string>, string>>;
+                }, import("zod/v4/core").$strict>>], null>], null>;
+                from: import("zod").ZodTuple<[import("zod/mini").ZodMiniTuple<readonly [import("zod/mini").ZodMiniObject<{
+                    schema: import("zod/mini").ZodMiniLiteral<"network.xyo.boundwitness" & {
+                        readonly __schema: true;
+                    }>;
+                    addresses: import("zod/mini").ZodMiniArray<import("zod/mini").ZodMiniUnion<readonly [import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<Lowercase<string> & {
+                        readonly __hex: true;
+                    } & {
+                        readonly __address: true;
+                    }, string>>, import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@xyo-network/sdk-protocol").XyoQuantAddress, string>>]>>;
+                    payload_hashes: import("zod/mini").ZodMiniArray<import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>>;
+                    payload_schemas: import("zod/mini").ZodMiniArray<import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@xyo-network/sdk-protocol").BrandedSchema<string>, string>>>;
+                    previous_hashes: import("zod/mini").ZodMiniArray<import("zod/mini").ZodMiniNullable<import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>>>;
+                    $destination: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniUnion<readonly [import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<Lowercase<string> & {
+                        readonly __hex: true;
+                    } & {
+                        readonly __address: true;
+                    }, string>>, import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@xyo-network/sdk-protocol").XyoQuantAddress, string>>]>>;
+                    $sourceQuery: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>>;
+                    $signatures: import("zod/mini").ZodMiniArray<import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHex, string>>>;
+                    nbf: import("zod").ZodPipe<import("zod").ZodInt, import("zod").ZodTransform<import("@xyo-network/xl1-protocol/protocol-lib").XL1BlockNumber, number>>;
+                    exp: import("zod").ZodPipe<import("zod").ZodInt, import("zod").ZodTransform<import("@xyo-network/xl1-protocol/protocol-lib").XL1BlockNumber, number>>;
+                    fees: import("zod/mini").ZodMiniObject<{
+                        base: import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHex, string>>;
+                        gasLimit: import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHex, string>>;
+                        gasPrice: import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHex, string>>;
+                        priority: import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHex, string>>;
+                    }, import("zod/v4/core").$strip>;
+                    chain: import("zod").ZodPipe<import("zod").ZodString, import("zod").ZodTransform<import("@ariestools/sdk").BrandedHex, string>>;
+                    from: import("zod/mini").ZodMiniUnion<readonly [import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<Lowercase<string> & {
+                        readonly __hex: true;
+                    } & {
+                        readonly __address: true;
+                    }, string>>, import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@xyo-network/sdk-protocol").XyoQuantAddress, string>>]>;
+                    script: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniArray<import("zod/mini").ZodMiniString<string>>>;
+                }, import("zod/v4/core").$strip>, import("zod/mini").ZodMiniArray<import("zod/mini").ZodMiniObject<{
+                    schema: import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@xyo-network/sdk-protocol").BrandedSchema<string>, string>>;
+                }, import("zod/v4/core").$strict>>], null>], null>;
+            };
+            result: {
+                to: import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>, import("zod/mini").ZodMiniTransform<string, import("@ariestools/sdk").BrandedHash>>;
+                from: import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<import("@ariestools/sdk").BrandedHash, string>>;
+            };
+        };
+    };
+}
+//# sourceMappingURL=JsonRpcXyoRunner.d.ts.map

package/dist/browser/modules/rpc/provider/runner/JsonRpcXyoRunner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"JsonRpcXyoRunner.d.ts","sourceRoot":"","sources":["../../../../../../src/modules/rpc/provider/runner/JsonRpcXyoRunner.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,IAAI,EAAE,MAAM,iBAAiB,CAAA;AAC3C,OAAO,KAAK,EACV,aAAa,EAAE,yBAAyB,EAAE,SAAS,EACpD,MAAM,wCAAwC,CAAA;AAK/C,OAAO,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAA;AAC1D,OAAO,EAAE,qBAAqB,EAAE,MAAM,oBAAoB,CAAA;AAE1D,uCAAuC;AACvC,qBACa,gBAAiB,SAAQ,qBAAqB,CAAC,mBAAmB,CAAE,YAAW,SAAS;IACnG,MAAM,CAAC,QAAQ,CAAC,eAAe,mBAAmB;IAClD,MAAM,CAAC,QAAQ,CAAC,cAAc,cAAmB;IACjD,MAAM,CAAC,QAAQ,CAAC,YAAY,oBAAyB;IACrD,MAAM,CAAC,QAAQ,CAAC,QAAQ,gBAAqB;IAC7C,MAAM,CAAC,QAAQ,CAAC,OAAO,EAAG,MAAM,CAAS;IACzC,OAAO,cAAkC;IAEzC,OAAO,CAAC,cAAc,CAAC,CAAe;IAEtC,IAAI,OAAO,kBAEV;IAEK,oBAAoB,CAAC,WAAW,EAAE,yBAAyB,GAAG,OAAO,CAAC,IAAI,CAAC;IAIlE,aAAa;IAK5B,SAAS,CAAC,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAGlB"}

package/dist/browser/modules/rpc/provider/runner/index.d.ts

@@ -0,0 +1,4 @@
+export * from './JsonRpcMempoolRunner/index.js';
+export * from './JsonRpcRunner.js';
+export * from './JsonRpcXyoRunner.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/browser/modules/rpc/provider/runner/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/modules/rpc/provider/runner/index.ts"],"names":[],"mappings":"AAAA,cAAc,iCAAiC,CAAA;AAC/C,cAAc,oBAAoB,CAAA;AAClC,cAAc,uBAAuB,CAAA"}

package/dist/browser/modules/rpc/provider/signer/JsonRpcXyoSigner.d.ts

@@ -0,0 +1,12 @@
+import type { SignedHydratedTransactionWithHashMeta, UnsignedHydratedTransaction, XyoSigner } from '@xyo-network/xl1-protocol/protocol-lib';
+import { JsonRpcXyoSignerMethods } from './JsonRpcXyoSignerMethods.js';
+/** JsonRpcXyoSigner implementation. */
+export declare class JsonRpcXyoSigner extends JsonRpcXyoSignerMethods implements XyoSigner {
+    static readonly connectionTypes: readonly ["rpc"];
+    static readonly defaultMoniker: "XyoSigner";
+    static readonly dependencies: never[];
+    static readonly monikers: "XyoSigner"[];
+    static readonly surface: "node";
+    signTransaction(tx: UnsignedHydratedTransaction): Promise<SignedHydratedTransactionWithHashMeta>;
+}
+//# sourceMappingURL=JsonRpcXyoSigner.d.ts.map