@xyo-network/xl1-rpc 1.2.3

package/dist/types/types/schema/common/TransactionBoundWitnessSchema.d.ts

@@ -0,0 +1,258 @@
+import z from 'zod';
+export declare const BlockStartSchema: z.ZodObject<{
+    nbf: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    nbf: number;
+}, {
+    nbf: number;
+}>;
+export declare const BlockEndSchema: z.ZodObject<{
+    exp: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    exp: number;
+}, {
+    exp: number;
+}>;
+export declare const BlockDurationSchema: z.ZodObject<{
+    nbf: z.ZodNumber;
+    exp: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    nbf: number;
+    exp: number;
+}, {
+    nbf: number;
+    exp: number;
+}>;
+export declare const TransactionFeesSchema: z.ZodObject<{
+    fees: z.ZodObject<{
+        base: z.ZodString;
+        gasLimit: z.ZodString;
+        gasPrice: z.ZodString;
+        priority: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        base: string;
+        gasLimit: string;
+        gasPrice: string;
+        priority: string;
+    }, {
+        base: string;
+        gasLimit: string;
+        gasPrice: string;
+        priority: string;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    fees: {
+        base: string;
+        gasLimit: string;
+        gasPrice: string;
+        priority: string;
+    };
+}, {
+    fees: {
+        base: string;
+        gasLimit: string;
+        gasPrice: string;
+        priority: string;
+    };
+}>;
+export declare const TransactionBoundWitnessSchema: z.ZodObject<{} & {
+    schema: z.ZodLiteral<"network.xyo.boundwitness">;
+} & {
+    addresses: z.ZodArray<z.ZodString, "many">;
+    payload_hashes: z.ZodArray<z.ZodString, "many">;
+    payload_schemas: z.ZodArray<z.ZodString, "many">;
+    previous_hashes: z.ZodArray<z.ZodNullable<z.ZodString>, "many">;
+} & {
+    $destination: z.ZodOptional<z.ZodString>;
+    $sourceQuery: z.ZodOptional<z.ZodString>;
+} & {
+    nbf: z.ZodNumber;
+    exp: z.ZodNumber;
+} & {
+    fees: z.ZodObject<{
+        base: z.ZodString;
+        gasLimit: z.ZodString;
+        gasPrice: z.ZodString;
+        priority: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        base: string;
+        gasLimit: string;
+        gasPrice: string;
+        priority: string;
+    }, {
+        base: string;
+        gasLimit: string;
+        gasPrice: string;
+        priority: string;
+    }>;
+} & {
+    chain: z.ZodString;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{} & {
+    schema: z.ZodLiteral<"network.xyo.boundwitness">;
+} & {
+    addresses: z.ZodArray<z.ZodString, "many">;
+    payload_hashes: z.ZodArray<z.ZodString, "many">;
+    payload_schemas: z.ZodArray<z.ZodString, "many">;
+    previous_hashes: z.ZodArray<z.ZodNullable<z.ZodString>, "many">;
+} & {
+    $destination: z.ZodOptional<z.ZodString>;
+    $sourceQuery: z.ZodOptional<z.ZodString>;
+} & {
+    nbf: z.ZodNumber;
+    exp: z.ZodNumber;
+} & {
+    fees: z.ZodObject<{
+        base: z.ZodString;
+        gasLimit: z.ZodString;
+        gasPrice: z.ZodString;
+        priority: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        base: string;
+        gasLimit: string;
+        gasPrice: string;
+        priority: string;
+    }, {
+        base: string;
+        gasLimit: string;
+        gasPrice: string;
+        priority: string;
+    }>;
+} & {
+    chain: z.ZodString;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{} & {
+    schema: z.ZodLiteral<"network.xyo.boundwitness">;
+} & {
+    addresses: z.ZodArray<z.ZodString, "many">;
+    payload_hashes: z.ZodArray<z.ZodString, "many">;
+    payload_schemas: z.ZodArray<z.ZodString, "many">;
+    previous_hashes: z.ZodArray<z.ZodNullable<z.ZodString>, "many">;
+} & {
+    $destination: z.ZodOptional<z.ZodString>;
+    $sourceQuery: z.ZodOptional<z.ZodString>;
+} & {
+    nbf: z.ZodNumber;
+    exp: z.ZodNumber;
+} & {
+    fees: z.ZodObject<{
+        base: z.ZodString;
+        gasLimit: z.ZodString;
+        gasPrice: z.ZodString;
+        priority: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        base: string;
+        gasLimit: string;
+        gasPrice: string;
+        priority: string;
+    }, {
+        base: string;
+        gasLimit: string;
+        gasPrice: string;
+        priority: string;
+    }>;
+} & {
+    chain: z.ZodString;
+}, z.ZodTypeAny, "passthrough">>;
+export declare const SignedTransactionBoundWitnessSchema: z.ZodObject<{} & {
+    schema: z.ZodLiteral<"network.xyo.boundwitness">;
+} & {
+    addresses: z.ZodArray<z.ZodString, "many">;
+    payload_hashes: z.ZodArray<z.ZodString, "many">;
+    payload_schemas: z.ZodArray<z.ZodString, "many">;
+    previous_hashes: z.ZodArray<z.ZodNullable<z.ZodString>, "many">;
+} & {
+    $destination: z.ZodOptional<z.ZodString>;
+    $sourceQuery: z.ZodOptional<z.ZodString>;
+} & {
+    $signatures: z.ZodArray<z.ZodString, "many">;
+} & {
+    nbf: z.ZodNumber;
+    exp: z.ZodNumber;
+} & {
+    fees: z.ZodObject<{
+        base: z.ZodString;
+        gasLimit: z.ZodString;
+        gasPrice: z.ZodString;
+        priority: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        base: string;
+        gasLimit: string;
+        gasPrice: string;
+        priority: string;
+    }, {
+        base: string;
+        gasLimit: string;
+        gasPrice: string;
+        priority: string;
+    }>;
+} & {
+    chain: z.ZodString;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{} & {
+    schema: z.ZodLiteral<"network.xyo.boundwitness">;
+} & {
+    addresses: z.ZodArray<z.ZodString, "many">;
+    payload_hashes: z.ZodArray<z.ZodString, "many">;
+    payload_schemas: z.ZodArray<z.ZodString, "many">;
+    previous_hashes: z.ZodArray<z.ZodNullable<z.ZodString>, "many">;
+} & {
+    $destination: z.ZodOptional<z.ZodString>;
+    $sourceQuery: z.ZodOptional<z.ZodString>;
+} & {
+    $signatures: z.ZodArray<z.ZodString, "many">;
+} & {
+    nbf: z.ZodNumber;
+    exp: z.ZodNumber;
+} & {
+    fees: z.ZodObject<{
+        base: z.ZodString;
+        gasLimit: z.ZodString;
+        gasPrice: z.ZodString;
+        priority: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        base: string;
+        gasLimit: string;
+        gasPrice: string;
+        priority: string;
+    }, {
+        base: string;
+        gasLimit: string;
+        gasPrice: string;
+        priority: string;
+    }>;
+} & {
+    chain: z.ZodString;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{} & {
+    schema: z.ZodLiteral<"network.xyo.boundwitness">;
+} & {
+    addresses: z.ZodArray<z.ZodString, "many">;
+    payload_hashes: z.ZodArray<z.ZodString, "many">;
+    payload_schemas: z.ZodArray<z.ZodString, "many">;
+    previous_hashes: z.ZodArray<z.ZodNullable<z.ZodString>, "many">;
+} & {
+    $destination: z.ZodOptional<z.ZodString>;
+    $sourceQuery: z.ZodOptional<z.ZodString>;
+} & {
+    $signatures: z.ZodArray<z.ZodString, "many">;
+} & {
+    nbf: z.ZodNumber;
+    exp: z.ZodNumber;
+} & {
+    fees: z.ZodObject<{
+        base: z.ZodString;
+        gasLimit: z.ZodString;
+        gasPrice: z.ZodString;
+        priority: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        base: string;
+        gasLimit: string;
+        gasPrice: string;
+        priority: string;
+    }, {
+        base: string;
+        gasLimit: string;
+        gasPrice: string;
+        priority: string;
+    }>;
+} & {
+    chain: z.ZodString;
+}, z.ZodTypeAny, "passthrough">>;
+//# sourceMappingURL=TransactionBoundWitnessSchema.d.ts.map

package/dist/types/types/schema/common/TransactionBoundWitnessSchema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TransactionBoundWitnessSchema.d.ts","sourceRoot":"","sources":["../../../../../src/types/schema/common/TransactionBoundWitnessSchema.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,KAAK,CAAA;AAOnB,eAAO,MAAM,gBAAgB;;;;;;EAAuC,CAAA;AACpE,eAAO,MAAM,cAAc;;;;;;EAAuC,CAAA;AAClE,eAAO,MAAM,mBAAmB;;;;;;;;;EAA+D,CAAA;AAE/F,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAOhC,CAAA;AAIF,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCAI1B,CAAA;AAEhB,eAAO,MAAM,mCAAmC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCAIhC,CAAA"}

package/dist/types/types/schema/common/TransactionFees.d.ts

@@ -0,0 +1,34 @@
+import { z } from 'zod';
+export declare const TransactionFeesToStingSchema: z.ZodObject<{
+    base: z.ZodEffects<z.ZodBigInt, Lowercase<string>, bigint>;
+    gasLimit: z.ZodEffects<z.ZodBigInt, Lowercase<string>, bigint>;
+    gasPrice: z.ZodEffects<z.ZodBigInt, Lowercase<string>, bigint>;
+    priority: z.ZodEffects<z.ZodBigInt, Lowercase<string>, bigint>;
+}, "strip", z.ZodTypeAny, {
+    base: Lowercase<string>;
+    gasLimit: Lowercase<string>;
+    gasPrice: Lowercase<string>;
+    priority: Lowercase<string>;
+}, {
+    base: bigint;
+    gasLimit: bigint;
+    gasPrice: bigint;
+    priority: bigint;
+}>;
+export declare const TransactionFeesFromStingSchema: z.ZodObject<{
+    base: z.ZodEffects<z.ZodString, bigint, string>;
+    gasLimit: z.ZodEffects<z.ZodString, bigint, string>;
+    gasPrice: z.ZodEffects<z.ZodString, bigint, string>;
+    priority: z.ZodEffects<z.ZodString, bigint, string>;
+}, "strip", z.ZodTypeAny, {
+    base: bigint;
+    gasLimit: bigint;
+    gasPrice: bigint;
+    priority: bigint;
+}, {
+    base: string;
+    gasLimit: string;
+    gasPrice: string;
+    priority: string;
+}>;
+//# sourceMappingURL=TransactionFees.d.ts.map

package/dist/types/types/schema/common/TransactionFees.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TransactionFees.d.ts","sourceRoot":"","sources":["../../../../../src/types/schema/common/TransactionFees.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAIvB,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;EAKvC,CAAA;AAEF,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;EAKzC,CAAA"}

package/dist/types/types/schema/common/index.d.ts

@@ -0,0 +1,14 @@
+export * from './AddressSchema.ts';
+export * from './BigIntSchema.ts';
+export * from './BlockBoundWitnessSchema.ts';
+export * from './BoundWitnessSchema.ts';
+export * from './HashSchema.ts';
+export * from './HexSchema.ts';
+export * from './HydratedBlockSchema.ts';
+export * from './HydratedTransactionSchema.ts';
+export * from './PayloadSchema.ts';
+export * from './SequenceSchema.ts';
+export * from './StorageMetaSchema.ts';
+export * from './TransactionBoundWitnessSchema.ts';
+export * from './TransactionFees.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/types/schema/common/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/types/schema/common/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAA;AAClC,cAAc,mBAAmB,CAAA;AACjC,cAAc,8BAA8B,CAAA;AAC5C,cAAc,yBAAyB,CAAA;AACvC,cAAc,iBAAiB,CAAA;AAC/B,cAAc,gBAAgB,CAAA;AAC9B,cAAc,0BAA0B,CAAA;AACxC,cAAc,gCAAgC,CAAA;AAC9C,cAAc,oBAAoB,CAAA;AAClC,cAAc,qBAAqB,CAAA;AACnC,cAAc,wBAAwB,CAAA;AACtC,cAAc,oCAAoC,CAAA;AAClD,cAAc,sBAAsB,CAAA"}

package/dist/types/types/schema/createRequestSchema.d.ts

@@ -0,0 +1,29 @@
+import type { ZodUndefined } from 'zod';
+import { z } from 'zod';
+export declare const createRequestSchema: <TParams extends z.ZodTypeAny, TMethodName extends string = string>(methodName: TMethodName, paramsSchema?: TParams | ZodUndefined) => z.ZodObject<{
+    id: z.ZodUnion<[z.ZodString, z.ZodNumber]>;
+    jsonrpc: z.ZodLiteral<"2.0">;
+    method: z.ZodLiteral<TMethodName>;
+    params: TParams | ZodUndefined;
+}, "strip", z.ZodTypeAny, z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
+    id: z.ZodUnion<[z.ZodString, z.ZodNumber]>;
+    jsonrpc: z.ZodLiteral<"2.0">;
+    method: z.ZodLiteral<TMethodName>;
+    params: TParams | ZodUndefined;
+}>, any> extends infer T ? { [k in keyof T]: z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
+    id: z.ZodUnion<[z.ZodString, z.ZodNumber]>;
+    jsonrpc: z.ZodLiteral<"2.0">;
+    method: z.ZodLiteral<TMethodName>;
+    params: TParams | ZodUndefined;
+}>, any>[k]; } : never, z.baseObjectInputType<{
+    id: z.ZodUnion<[z.ZodString, z.ZodNumber]>;
+    jsonrpc: z.ZodLiteral<"2.0">;
+    method: z.ZodLiteral<TMethodName>;
+    params: TParams | ZodUndefined;
+}> extends infer T_1 ? { [k_1 in keyof T_1]: z.baseObjectInputType<{
+    id: z.ZodUnion<[z.ZodString, z.ZodNumber]>;
+    jsonrpc: z.ZodLiteral<"2.0">;
+    method: z.ZodLiteral<TMethodName>;
+    params: TParams | ZodUndefined;
+}>[k_1]; } : never>;
+//# sourceMappingURL=createRequestSchema.d.ts.map

package/dist/types/types/schema/createRequestSchema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createRequestSchema.d.ts","sourceRoot":"","sources":["../../../../src/types/schema/createRequestSchema.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,KAAK,CAAA;AACvC,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAIvB,eAAO,MAAM,mBAAmB,GAAI,OAAO,SAAS,CAAC,CAAC,UAAU,EAAE,WAAW,SAAS,MAAM,GAAG,MAAM,EACnG,YAAY,WAAW,EACvB,eAAc,OAAO,GAAG,YAA4B;;;;;;;;;;;;;;;;;;;;;;;;;mBAOlD,CAAA"}

package/dist/types/types/schema/createResponseSchema.d.ts

@@ -0,0 +1,24 @@
+import type { ZodUndefined } from 'zod';
+import { z } from 'zod';
+export declare const createResponseSchema: <TParams extends z.ZodTypeAny>(resultSchema?: TParams | ZodUndefined) => z.ZodObject<{
+    id: z.ZodUnion<[z.ZodString, z.ZodNumber]>;
+    jsonrpc: z.ZodLiteral<"2.0">;
+    result: ZodUndefined | TParams;
+}, "strip", z.ZodTypeAny, z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
+    id: z.ZodUnion<[z.ZodString, z.ZodNumber]>;
+    jsonrpc: z.ZodLiteral<"2.0">;
+    result: ZodUndefined | TParams;
+}>, any> extends infer T ? { [k in keyof T]: z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
+    id: z.ZodUnion<[z.ZodString, z.ZodNumber]>;
+    jsonrpc: z.ZodLiteral<"2.0">;
+    result: ZodUndefined | TParams;
+}>, any>[k]; } : never, z.baseObjectInputType<{
+    id: z.ZodUnion<[z.ZodString, z.ZodNumber]>;
+    jsonrpc: z.ZodLiteral<"2.0">;
+    result: ZodUndefined | TParams;
+}> extends infer T_1 ? { [k_1 in keyof T_1]: z.baseObjectInputType<{
+    id: z.ZodUnion<[z.ZodString, z.ZodNumber]>;
+    jsonrpc: z.ZodLiteral<"2.0">;
+    result: ZodUndefined | TParams;
+}>[k_1]; } : never>;
+//# sourceMappingURL=createResponseSchema.d.ts.map

package/dist/types/types/schema/createResponseSchema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createResponseSchema.d.ts","sourceRoot":"","sources":["../../../../src/types/schema/createResponseSchema.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,KAAK,CAAA;AACvC,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAIvB,eAAO,MAAM,oBAAoB,GAAI,OAAO,SAAS,CAAC,CAAC,UAAU,EAC/D,eAAc,OAAO,GAAG,YAA4B;;;;;;;;;;;;;;;;;;;;mBAMlD,CAAA"}

package/dist/types/types/schema/index.d.ts

@@ -0,0 +1,10 @@
+export * from './AllRpcSchemas.ts';
+export * from './createRequestSchema.ts';
+export * from './createResponseSchema.ts';
+export * from './RpcSchemaMap.ts';
+export * from './XyoProviderRpcSchemas.ts';
+export * from './XyoRunnerRpcSchemas.ts';
+export * from './XyoSignerRpcSchemas.ts';
+export * from './XyoViewerRpcSchemas.ts';
+export * from './XyoWalletRpcSchemas.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/types/schema/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/types/schema/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAA;AAClC,cAAc,0BAA0B,CAAA;AACxC,cAAc,2BAA2B,CAAA;AACzC,cAAc,mBAAmB,CAAA;AACjC,cAAc,4BAA4B,CAAA;AAC1C,cAAc,0BAA0B,CAAA;AACxC,cAAc,0BAA0B,CAAA;AACxC,cAAc,0BAA0B,CAAA;AACxC,cAAc,0BAA0B,CAAA"}

package/package.json

@@ -0,0 +1,91 @@
+{
+  "$schema": "http://json.schemastore.org/package.json",
+  "name": "@xyo-network/xl1-rpc",
+  "version": "1.2.3",
+  "description": "XYO Layer One API",
+  "homepage": "https://xylabs.com",
+  "bugs": {
+    "url": "git+https://github.com/xylabs/xyo-chain/issues",
+    "email": "support@xylabs.com"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/xylabs/xyo-chain.git"
+  },
+  "license": "LGPL-3.0-only",
+  "author": {
+    "name": "XY Labs Development Team",
+    "email": "support@xylabs.com",
+    "url": "https://xylabs.com"
+  },
+  "sideEffects": false,
+  "type": "module",
+  "exports": {
+    ".": {
+      "browser": {
+        "types": "./dist/types/index.d.ts",
+        "default": "./dist/browser/index.mjs"
+      },
+      "node": {
+        "types": "./dist/types/index.d.ts",
+        "default": "./dist/node/index.mjs"
+      },
+      "neutral": {
+        "types": "./dist/types/index.d.ts",
+        "default": "./dist/neutral/index.mjs"
+      }
+    },
+    "./package.json": "./package.json"
+  },
+  "module": "./dist/neutral/index.mjs",
+  "types": "./dist/types/index.d.ts",
+  "scripts": {
+    "build-tests": "tsc --noEmit --lib dom,esnext",
+    "deploy": "echo Deploy not allowed!",
+    "deploy3": "echo Deploy3 not allowed!",
+    "start": "nodemon",
+    "start-esm": "node ./dist/node/index.mjs",
+    "test": "vitest run",
+    "test:ci": "vitest run",
+    "types": "tsc --noEmit -p tsconfig.test.json"
+  },
+  "dependencies": {
+    "@metamask/json-rpc-engine": "^10.0.3",
+    "@metamask/utils": "^11.4.0",
+    "@xylabs/assert": "^4.8.7",
+    "@xylabs/axios": "^4.8.7",
+    "@xylabs/hex": "^4.8.7",
+    "@xyo-network/archivist-memory": "^3.13.0",
+    "@xyo-network/boundwitness-model": "^3.13.0",
+    "@xyo-network/chain-modules": "^1.3.3",
+    "@xyo-network/diviner-model": "^3.13.0",
+    "@xyo-network/module-model": "^3.13.0",
+    "@xyo-network/node-model": "^3.13.0",
+    "@xyo-network/payload-model": "^3.13.0",
+    "@xyo-network/payload-wrapper": "^3.13.0",
+    "@xyo-network/xl1-model": "^1.3.3",
+    "@xyo-network/xl1-protocol": "^1.3.3",
+    "uuid": "^11.1.0",
+    "zod": "^3.24.3"
+  },
+  "devDependencies": {
+    "@types/node": "^22.14.1",
+    "@xylabs/ts-scripts-yarn3": "^6.3.4",
+    "@xylabs/tsconfig": "^6.3.4",
+    "dotenv": "^16.5.0",
+    "nodemon": "^3.1.9",
+    "typescript": "^5.8.3",
+    "vitest": "^3.1.2"
+  },
+  "packageManager": "yarn@4.6.0",
+  "engines": {
+    "node": ">=22"
+  },
+  "volta": {
+    "node": "22.5.1",
+    "yarn": "4.6.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/src/engine/index.ts

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

package/src/engine/rpcEngineFromProvider.ts

@@ -0,0 +1,61 @@
+import { createAsyncMiddleware, JsonRpcEngine } from '@metamask/json-rpc-engine'
+import type { Json } from '@metamask/utils'
+import type { XyoProvider } from '@xyo-network/xl1-model'
+import type { z } from 'zod'
+
+import {
+  AllRpcSchemas,
+  createRequestSchema,
+  JsonRpcErrorCodes,
+} from '../types/index.ts'
+import { rpcMethodHandlersFromProvider } from './rpcMethodHandlersFromProvider.ts'
+
+const requestSchemas: Record<string, z.AnyZodObject> = {}
+
+export const rpcEngineFromProvider = (provider: XyoProvider) => {
+  const engine = new JsonRpcEngine()
+  const handlers = rpcMethodHandlersFromProvider(provider)
+  engine.push(
+    createAsyncMiddleware(async (req, res) => {
+      // Get method name
+      const method = req.method as keyof typeof handlers & keyof typeof requestSchemas
+      // Get schema for method
+      const handler = handlers[method]
+      // Get handler for method
+      const schema = AllRpcSchemas[method]
+
+      // If no schema or handler exists
+      if (!schema || !handler) {
+        // return method not found error
+        res.error = JsonRpcErrorCodes.MethodNotFound
+        return
+      }
+
+      // Validate request according to schema
+      let requestSchema = requestSchemas[method]
+      if (!requestSchema) {
+        requestSchema = createRequestSchema(method, schema.params.from)
+        requestSchemas[method] = requestSchema
+      }
+
+      const parsed = requestSchema.safeParse(req)
+      // If validation fails
+      if (!parsed.success) {
+        res.error = {
+          // Return invalid params error
+          ...JsonRpcErrorCodes.InvalidParams,
+          // with the specific validation error message
+          message: parsed.error.message,
+        }
+        return
+      }
+
+      // Call handler with validated params
+      const { params } = parsed.data
+      const result = await handler(params as never)
+      // Parse handler result according to schema
+      res.result = schema.result.to.parse(result) as Json
+    }),
+  )
+  return engine
+}

package/src/engine/rpcMethodHandlersFromProvider.ts

@@ -0,0 +1,19 @@
+import type { XyoProvider } from '@xyo-network/xl1-model'
+
+import type { XyoProviderRpcMethodHandlers } from '../types/index.ts'
+import { rpcMethodHandlersFromRunner } from './rpcMethodHandlersFromRunner.ts'
+import { rpcMethodHandlersFromSigner } from './rpcMethodHandlersFromSigner.ts'
+import { rpcMethodHandlersFromViewer } from './rpcMethodHandlersFromViewer.ts'
+import { rpcMethodHandlersFromWallet } from './rpcMethodHandlersFromWallet.ts'
+
+export const rpcMethodHandlersFromProvider = (provider: XyoProvider): XyoProviderRpcMethodHandlers => {
+  const {
+    runner, signer, viewer, wallet,
+  } = provider
+  let result: XyoProviderRpcMethodHandlers = { xyoProvider_send: params => (provider as Required<XyoProvider>).send(...(params ?? [])) }
+  if (runner) result = { ...result, ...rpcMethodHandlersFromRunner(runner) }
+  if (signer) result = { ...result, ...rpcMethodHandlersFromSigner(signer) }
+  if (viewer) result = { ...result, ...rpcMethodHandlersFromViewer(viewer) }
+  if (wallet) result = { ...result, ...rpcMethodHandlersFromWallet(wallet) }
+  return result
+}

package/src/engine/rpcMethodHandlersFromRunner.ts

@@ -0,0 +1,7 @@
+import type { XyoRunner } from '@xyo-network/xl1-model'
+
+import type { XyoRunnerRpcMethodHandlers } from '../types/index.ts'
+
+export const rpcMethodHandlersFromRunner = (runner: XyoRunner): XyoRunnerRpcMethodHandlers => {
+  return { xyoRunner_broadcastTransaction: params => runner.broadcastTransaction(...(params ?? [])) }
+}

package/src/engine/rpcMethodHandlersFromSigner.ts

@@ -0,0 +1,10 @@
+import type { XyoSigner } from '@xyo-network/xl1-model'
+
+import type { XyoSignerRpcMethodHandlers } from '../types/index.ts'
+
+export const rpcMethodHandlersFromSigner = (signer: XyoSigner): XyoSignerRpcMethodHandlers => {
+  return {
+    xyoSigner_address: params => signer.address(...(params ?? [])),
+    xyoSigner_createSignedTransaction: params => signer.createSignedTransaction(...(params ?? [])),
+  }
+}

package/src/engine/rpcMethodHandlersFromViewer.ts

@@ -0,0 +1,19 @@
+import type { XyoViewer } from '@xyo-network/xl1-model'
+
+import type { XyoViewerRpcMethodHandlers } from '../types/index.ts'
+
+export const rpcMethodHandlersFromViewer = (viewer: XyoViewer): XyoViewerRpcMethodHandlers => {
+  return {
+    xyoViewer_accountBalance: params => viewer.accountBalance(...(params ?? [])),
+    xyoViewer_blockByHash: params => viewer.blockByHash(...(params ?? [])),
+    xyoViewer_blockByNumber: params => viewer.blockByNumber(...(params ?? [])),
+    xyoViewer_blocksByHash: params => viewer.blocksByHash(...(params ?? [])),
+    xyoViewer_chainId: params => viewer.chainId(...(params ?? [])),
+    xyoViewer_currentBlock: params => viewer.currentBlock(...(params ?? [])),
+    xyoViewer_currentBlockHash: params => viewer.currentBlockHash(...(params ?? [])),
+    xyoViewer_currentBlockNumber: params => viewer.currentBlockNumber(...(params ?? [])),
+    xyoViewer_transactionByBlockHashAndIndex: params => viewer.transactionByBlockHashAndIndex(...(params ?? [])),
+    xyoViewer_transactionByBlockNumberAndIndex: params => viewer.transactionByBlockNumberAndIndex(...(params ?? [])),
+    xyoViewer_transactionByHash: params => viewer.transactionByHash(...(params ?? [])),
+  }
+}

package/src/engine/rpcMethodHandlersFromWallet.ts

@@ -0,0 +1,16 @@
+import type { XyoWallet } from '@xyo-network/xl1-model'
+
+import type { XyoWalletRpcMethodHandlers } from '../types/index.ts'
+
+export const rpcMethodHandlersFromWallet = (wallet: XyoWallet): XyoWalletRpcMethodHandlers => {
+  return {
+    xyoWallet_accounts: params => wallet.accounts(...(params ?? [])),
+    xyoWallet_addChain: params => wallet.addChain(...(params ?? [])),
+    xyoWallet_chain: params => wallet.chain(...(params ?? [])),
+    xyoWallet_chains: params => wallet.chains(...(params ?? [])),
+    xyoWallet_permissions: params => wallet.permissions(...(params ?? [])),
+    xyoWallet_requestPermissions: params => wallet.requestPermissions(...(params ?? [])),
+    xyoWallet_revokePermissions: params => wallet.revokePermissions(...(params ?? [])),
+    xyoWallet_switchChain: params => wallet.switchChain(...(params ?? [])),
+  }
+}

package/src/index.ts

@@ -0,0 +1,4 @@
+export * from './engine/index.ts'
+export * from './provider/index.ts'
+export * from './transport/index.ts'
+export * from './types/index.ts'

package/src/provider/index.ts

@@ -0,0 +1,5 @@
+export * from './provider/index.ts'
+export * from './runner/index.ts'
+export * from './signer/index.ts'
+export * from './viewer/index.ts'
+export * from './wallet/index.ts'