@xyo-network/xl1-rpc 1.2.3

package/dist/neutral/index.mjs

@@ -0,0 +1,1247 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// src/engine/rpcEngineFromProvider.ts
+import { createAsyncMiddleware, JsonRpcEngine } from "@metamask/json-rpc-engine";
+
+// src/types/ErrorCodes.ts
+var JsonRpcErrorCodes = {
+  InternalError: {
+    code: -32603,
+    message: "Internal JSON-RPC error (unexpected exception)."
+  },
+  InvalidParams: {
+    code: -32602,
+    message: "Invalid method parameter(s)."
+  },
+  InvalidRequest: {
+    code: -32600,
+    message: "The JSON sent is not a valid Request object."
+  },
+  MethodNotFound: {
+    code: -32601,
+    message: "The method does not exist or is not available."
+  }
+};
+
+// src/types/JsonRpc.ts
+var jsonrpc = "2.0";
+
+// src/types/schema/XyoProviderRpcSchemas.ts
+import { z as z14 } from "zod";
+
+// src/types/schema/common/AddressSchema.ts
+import { toAddress } from "@xylabs/hex";
+import { AddressRegEx } from "@xyo-network/payload-wrapper";
+import { z } from "zod";
+var CompiledAddressRegEx = new RegExp(AddressRegEx);
+var AddressToStringSchema = z.string().toLowerCase().regex(CompiledAddressRegEx);
+var AddressFromStringSchema = z.string().toLowerCase().regex(CompiledAddressRegEx).transform((v) => toAddress(v));
+
+// src/types/schema/common/BigIntSchema.ts
+import { hexToBigInt, toHex } from "@xylabs/hex";
+import { HexRegEx } from "@xyo-network/payload-wrapper";
+import { z as z2 } from "zod";
+var CompiledHexRegEx = new RegExp(HexRegEx);
+var BigIntToStringSchema = z2.bigint().nonnegative().transform((x) => toHex(x));
+var BigIntFromStringSchema = z2.string().regex(CompiledHexRegEx).transform((x) => hexToBigInt(toHex(x)));
+
+// src/types/schema/common/BlockBoundWitnessSchema.ts
+import { z as z9 } from "zod";
+
+// src/types/schema/common/BoundWitnessSchema.ts
+import { BoundWitnessSchema } from "@xyo-network/boundwitness-model";
+import { z as z8 } from "zod";
+
+// src/types/schema/common/HashSchema.ts
+import { toHex as toHex2 } from "@xylabs/hex";
+import { HashRegEx } from "@xyo-network/payload-wrapper";
+import { z as z3 } from "zod";
+var HashToStringSchema = z3.string().toLowerCase().regex(new RegExp(HashRegEx));
+var HashFromStringSchema = z3.string().toLowerCase().regex(new RegExp(HashRegEx)).transform((v) => toHex2(v));
+
+// src/types/schema/common/HexSchema.ts
+import { toHex as toHex3 } from "@xylabs/hex";
+import { HexRegEx as HexRegEx2 } from "@xyo-network/payload-wrapper";
+import { z as z4 } from "zod";
+var HexToStringSchema = z4.string().toLowerCase().regex(new RegExp(HexRegEx2));
+var HexFromStringSchema = z4.string().toLowerCase().regex(new RegExp(HexRegEx2)).transform((v) => toHex3(v));
+
+// src/types/schema/common/PayloadSchema.ts
+import { z as z7 } from "zod";
+
+// src/types/schema/common/StorageMetaSchema.ts
+import { z as z6 } from "zod";
+
+// src/types/schema/common/SequenceSchema.ts
+import { toHex as toHex4 } from "@xylabs/hex";
+import { SequenceConstants } from "@xyo-network/payload-model";
+import { HexRegExMinMax } from "@xyo-network/payload-wrapper";
+import { z as z5 } from "zod";
+var LocalSequenceRegex = new RegExp(HexRegExMinMax(SequenceConstants.localSequenceBytes, SequenceConstants.localSequenceBytes));
+var LocalSequenceToStringSchema = z5.string().regex(LocalSequenceRegex);
+var LocalSequenceFromStringSchema = z5.string().regex(LocalSequenceRegex).transform((v) => toHex4(v));
+var QualifiedSequenceRegex = new RegExp(HexRegExMinMax(SequenceConstants.qualifiedSequenceBytes, SequenceConstants.qualifiedSequenceBytes));
+var QualifiedSequenceToStringSchema = z5.string().regex(QualifiedSequenceRegex);
+var QualifiedSequenceFromStringSchema = z5.string().regex(QualifiedSequenceRegex).transform((v) => toHex4(v));
+var SequenceToStringSchema = z5.union([
+  LocalSequenceToStringSchema,
+  QualifiedSequenceToStringSchema
+]);
+var SequenceFromStringSchema = z5.union([
+  LocalSequenceFromStringSchema,
+  QualifiedSequenceFromStringSchema
+]);
+
+// src/types/schema/common/StorageMetaSchema.ts
+var StorageMetaSchema = z6.object({
+  _hash: HashToStringSchema,
+  _dataHash: HashToStringSchema,
+  _sequence: SequenceToStringSchema
+});
+
+// src/types/schema/common/PayloadSchema.ts
+var PayloadSchema = z7.object({
+  schema: z7.string()
+}).passthrough();
+var PayloadWithStorageMetaSchema = PayloadSchema.extend(StorageMetaSchema.shape).passthrough();
+
+// src/types/schema/common/BoundWitnessSchema.ts
+var SchemaIdSchema = z8.string();
+var BoundWitnessRequiredFieldsSchema = z8.object({
+  addresses: z8.array(AddressToStringSchema),
+  payload_hashes: z8.array(HashToStringSchema),
+  payload_schemas: z8.array(SchemaIdSchema),
+  previous_hashes: z8.array(HashToStringSchema.nullable())
+});
+var BoundWitnessMetaSchema = z8.object({
+  $destination: AddressToStringSchema.optional(),
+  $sourceQuery: HashToStringSchema.optional()
+});
+var UnsignedBoundWitnessSchema = PayloadSchema.extend({
+  schema: z8.literal(BoundWitnessSchema)
+}).merge(BoundWitnessRequiredFieldsSchema).merge(BoundWitnessMetaSchema).passthrough();
+var UnsignedBoundWitnessWithStorageMetaSchema = PayloadWithStorageMetaSchema.extend({
+  schema: z8.literal(BoundWitnessSchema)
+}).merge(BoundWitnessRequiredFieldsSchema).merge(BoundWitnessMetaSchema).passthrough();
+var SignedBoundWitnessSchema = UnsignedBoundWitnessSchema.extend({
+  $signatures: z8.array(HexToStringSchema)
+}).passthrough();
+var SignedBoundWitnessWithStorageMetaSchema = UnsignedBoundWitnessWithStorageMetaSchema.extend({
+  $signatures: z8.array(HexToStringSchema)
+}).passthrough();
+
+// src/types/schema/common/BlockBoundWitnessSchema.ts
+var BlockNumberSchema = z9.number().int().nonnegative();
+var BlockBoundWitnessFieldsSchema = z9.object({
+  block: BlockNumberSchema,
+  chain: HexToStringSchema,
+  previous: HexToStringSchema.nullable(),
+  protocol: z9.number().optional(),
+  step_hashes: z9.array(HexToStringSchema).optional()
+});
+var BlockBoundWitnessSchema = UnsignedBoundWitnessSchema.merge(BlockBoundWitnessFieldsSchema).passthrough();
+var BlockBoundWitnessWithStorageMetaSchema = UnsignedBoundWitnessWithStorageMetaSchema.merge(BlockBoundWitnessFieldsSchema).passthrough();
+var SignedBlockBoundWitnessSchema = SignedBoundWitnessSchema.merge(BlockBoundWitnessFieldsSchema).passthrough();
+var SignedBlockBoundWitnessWithStorageMetaSchema = SignedBoundWitnessWithStorageMetaSchema.merge(BlockBoundWitnessFieldsSchema).passthrough();
+
+// src/types/schema/common/HydratedBlockSchema.ts
+import { z as z10 } from "zod";
+var HydratedBlockSchema = z10.tuple([
+  BlockBoundWitnessSchema,
+  z10.array(PayloadSchema)
+]);
+var HydratedBlockWithStorageMetaSchema = z10.tuple([
+  BlockBoundWitnessWithStorageMetaSchema,
+  z10.array(PayloadWithStorageMetaSchema)
+]);
+var SignedHydratedBlockSchema = z10.tuple([
+  SignedBlockBoundWitnessSchema,
+  z10.array(PayloadSchema)
+]);
+var SignedHydratedBlockWithStorageMetaSchema = z10.tuple([
+  SignedBlockBoundWitnessWithStorageMetaSchema,
+  z10.array(PayloadWithStorageMetaSchema)
+]);
+
+// src/types/schema/common/HydratedTransactionSchema.ts
+import { z as z12 } from "zod";
+
+// src/types/schema/common/TransactionBoundWitnessSchema.ts
+import z11 from "zod";
+var BlockStartSchema = z11.object({
+  nbf: BlockNumberSchema
+});
+var BlockEndSchema = z11.object({
+  exp: BlockNumberSchema
+});
+var BlockDurationSchema = z11.object({
+  nbf: BlockNumberSchema,
+  exp: BlockNumberSchema
+});
+var TransactionFeesSchema = z11.object({
+  fees: z11.object({
+    base: HexToStringSchema,
+    gasLimit: HexToStringSchema,
+    gasPrice: HexToStringSchema,
+    priority: HexToStringSchema
+  })
+});
+var TransactionBoundWitnessFields = z11.object({
+  chain: AddressToStringSchema
+});
+var TransactionBoundWitnessSchema = UnsignedBoundWitnessSchema.merge(BlockDurationSchema).merge(TransactionFeesSchema).merge(TransactionBoundWitnessFields).passthrough();
+var SignedTransactionBoundWitnessSchema = SignedBoundWitnessSchema.merge(BlockDurationSchema).merge(TransactionFeesSchema).merge(TransactionBoundWitnessFields).passthrough();
+
+// src/types/schema/common/HydratedTransactionSchema.ts
+var HydratedTransactionSchema = z12.tuple([
+  TransactionBoundWitnessSchema,
+  z12.array(PayloadSchema)
+]);
+var SignedHydratedTransactionSchema = z12.tuple([
+  SignedTransactionBoundWitnessSchema,
+  z12.array(PayloadSchema)
+]);
+
+// src/types/schema/common/TransactionFees.ts
+import { z as z13 } from "zod";
+var TransactionFeesToStingSchema = z13.object({
+  base: BigIntToStringSchema,
+  gasLimit: BigIntToStringSchema,
+  gasPrice: BigIntToStringSchema,
+  priority: BigIntToStringSchema
+});
+var TransactionFeesFromStingSchema = z13.object({
+  base: BigIntFromStringSchema,
+  gasLimit: BigIntFromStringSchema,
+  gasPrice: BigIntFromStringSchema,
+  priority: BigIntFromStringSchema
+});
+
+// src/types/schema/XyoProviderRpcSchemas.ts
+var XyoProviderRpcSchemas = {
+  xyoProvider_send: {
+    params: {
+      to: z14.tuple([
+        AddressFromStringSchema,
+        z14.array(PayloadSchema),
+        z14.array(PayloadSchema),
+        z14.number().nonnegative(),
+        z14.number().nonnegative(),
+        TransactionFeesToStingSchema,
+        AddressFromStringSchema.optional()
+      ]),
+      from: z14.tuple([
+        AddressToStringSchema,
+        z14.array(PayloadSchema),
+        z14.array(PayloadSchema),
+        z14.number().nonnegative(),
+        z14.number().nonnegative(),
+        TransactionFeesFromStingSchema,
+        AddressToStringSchema.optional()
+      ])
+    },
+    result: {
+      to: SignedTransactionBoundWitnessSchema,
+      from: SignedTransactionBoundWitnessSchema
+    }
+  }
+};
+
+// src/types/schema/XyoRunnerRpcSchemas.ts
+import { z as z15 } from "zod";
+var XyoRunnerRpcSchemas = {
+  xyoRunner_broadcastTransaction: {
+    params: {
+      to: z15.tuple([
+        SignedHydratedTransactionSchema
+      ]),
+      from: z15.tuple([
+        SignedHydratedTransactionSchema
+      ])
+    },
+    result: {
+      to: HashToStringSchema,
+      from: HashFromStringSchema
+    }
+  }
+};
+
+// src/types/schema/XyoSignerRpcSchemas.ts
+import { z as z16 } from "zod";
+var XyoSignerRpcSchemas = {
+  xyoSigner_address: {
+    params: {
+      to: z16.array(z16.any()).length(0).optional(),
+      from: z16.array(z16.any()).length(0).optional()
+    },
+    result: {
+      to: AddressToStringSchema,
+      from: AddressFromStringSchema
+    }
+  },
+  xyoSigner_createSignedTransaction: {
+    params: {
+      to: z16.tuple([
+        AddressFromStringSchema,
+        z16.array(PayloadSchema),
+        z16.array(PayloadSchema),
+        z16.number().nonnegative(),
+        z16.number().nonnegative(),
+        TransactionFeesToStingSchema,
+        AddressFromStringSchema.optional()
+      ]),
+      from: z16.tuple([
+        AddressToStringSchema,
+        z16.array(PayloadSchema),
+        z16.array(PayloadSchema),
+        z16.number().nonnegative(),
+        z16.number().nonnegative(),
+        TransactionFeesFromStingSchema,
+        AddressToStringSchema.optional()
+      ])
+    },
+    result: {
+      to: SignedTransactionBoundWitnessSchema,
+      from: SignedTransactionBoundWitnessSchema
+    }
+  }
+};
+
+// src/types/schema/XyoViewerRpcSchemas.ts
+import { z as z17 } from "zod";
+var XyoViewerRpcSchemas = {
+  xyoViewer_accountBalance: {
+    params: {
+      to: z17.tuple([
+        AddressToStringSchema,
+        z17.number(),
+        z17.boolean()
+      ]),
+      from: z17.tuple([
+        AddressFromStringSchema,
+        z17.number(),
+        z17.boolean()
+      ])
+    },
+    result: {
+      to: BigIntToStringSchema,
+      from: BigIntFromStringSchema
+    }
+  },
+  xyoViewer_blockByHash: {
+    params: {
+      to: z17.tuple([
+        HashToStringSchema
+      ]),
+      from: z17.tuple([
+        HashFromStringSchema
+      ])
+    },
+    result: {
+      to: SignedHydratedBlockSchema,
+      from: SignedHydratedBlockSchema
+    }
+  },
+  xyoViewer_blockByNumber: {
+    params: {
+      to: z17.tuple([
+        z17.number()
+      ]),
+      from: z17.tuple([
+        z17.number()
+      ])
+    },
+    result: {
+      to: SignedHydratedBlockSchema,
+      from: SignedHydratedBlockSchema
+    }
+  },
+  xyoViewer_blocksByHash: {
+    params: {
+      to: z17.tuple([
+        HashToStringSchema,
+        z17.number().optional()
+      ]),
+      from: z17.tuple([
+        HashFromStringSchema,
+        z17.number().optional()
+      ])
+    },
+    result: {
+      to: z17.array(SignedHydratedBlockSchema),
+      from: z17.array(SignedHydratedBlockSchema)
+    }
+  },
+  xyoViewer_chainId: {
+    params: {
+      to: z17.array(z17.any()).length(0).optional(),
+      from: z17.array(z17.any()).length(0).optional()
+    },
+    result: {
+      to: AddressToStringSchema,
+      from: AddressFromStringSchema
+    }
+  },
+  xyoViewer_currentBlock: {
+    params: {
+      to: z17.array(z17.any()).length(0).optional(),
+      from: z17.array(z17.any()).length(0).optional()
+    },
+    result: {
+      to: SignedHydratedBlockSchema,
+      from: SignedHydratedBlockSchema
+    }
+  },
+  xyoViewer_currentBlockHash: {
+    params: {
+      to: z17.array(z17.any()).length(0).optional(),
+      from: z17.array(z17.any()).length(0).optional()
+    },
+    result: {
+      to: HashToStringSchema,
+      from: HashFromStringSchema
+    }
+  },
+  xyoViewer_currentBlockNumber: {
+    params: {
+      to: z17.array(z17.any()).length(0).optional(),
+      from: z17.array(z17.any()).length(0).optional()
+    },
+    result: {
+      to: BlockNumberSchema,
+      from: BlockNumberSchema
+    }
+  },
+  xyoViewer_transactionByBlockHashAndIndex: {
+    params: {
+      to: z17.tuple([
+        HashToStringSchema,
+        z17.number()
+      ]),
+      from: z17.tuple([
+        HashFromStringSchema,
+        z17.number()
+      ])
+    },
+    result: {
+      to: SignedHydratedTransactionSchema.nullable(),
+      from: SignedHydratedTransactionSchema.nullable()
+    }
+  },
+  xyoViewer_transactionByBlockNumberAndIndex: {
+    params: {
+      to: z17.tuple([
+        z17.number(),
+        z17.number()
+      ]),
+      from: z17.tuple([
+        z17.number(),
+        z17.number()
+      ])
+    },
+    result: {
+      to: SignedHydratedTransactionSchema.nullable(),
+      from: SignedHydratedTransactionSchema.nullable()
+    }
+  },
+  xyoViewer_transactionByHash: {
+    params: {
+      to: z17.tuple([
+        HashToStringSchema
+      ]),
+      from: z17.tuple([
+        HashFromStringSchema
+      ])
+    },
+    result: {
+      to: SignedHydratedTransactionSchema.nullable(),
+      from: SignedHydratedTransactionSchema.nullable()
+    }
+  }
+};
+
+// src/types/schema/XyoWalletRpcSchemas.ts
+import { z as z18 } from "zod";
+var XyoWalletRpcSchemas = {
+  xyoWallet_accounts: {
+    params: {
+      to: z18.array(z18.any()).length(0).optional(),
+      from: z18.array(z18.any()).length(0).optional()
+    },
+    result: {
+      to: z18.array(AddressToStringSchema),
+      from: z18.array(AddressFromStringSchema)
+    }
+  },
+  xyoWallet_addChain: {
+    params: {
+      to: z18.array(z18.any()).length(0).optional(),
+      from: z18.array(z18.any()).length(0).optional()
+    },
+    result: {
+      from: z18.any(),
+      to: z18.any()
+    }
+  },
+  xyoWallet_chain: {
+    params: {
+      to: z18.array(z18.any()).length(0).optional(),
+      from: z18.array(z18.any()).length(0).optional()
+    },
+    result: {
+      to: AddressToStringSchema,
+      from: AddressFromStringSchema
+    }
+  },
+  xyoWallet_chains: {
+    params: {
+      to: z18.array(z18.any()).length(0).optional(),
+      from: z18.array(z18.any()).length(0).optional()
+    },
+    result: {
+      from: z18.any(),
+      to: z18.any()
+    }
+  },
+  xyoWallet_permissions: {
+    params: {
+      to: z18.array(z18.any()).length(0).optional(),
+      from: z18.array(z18.any()).length(0).optional()
+    },
+    result: {
+      from: z18.any(),
+      to: z18.any()
+    }
+  },
+  xyoWallet_requestPermissions: {
+    params: {
+      to: z18.array(z18.any()).length(0).optional(),
+      from: z18.array(z18.any()).length(0).optional()
+    },
+    result: {
+      from: z18.any(),
+      to: z18.any()
+    }
+  },
+  xyoWallet_revokePermissions: {
+    params: {
+      to: z18.array(z18.any()).length(0).optional(),
+      from: z18.array(z18.any()).length(0).optional()
+    },
+    result: {
+      from: z18.any(),
+      to: z18.any()
+    }
+  },
+  xyoWallet_switchChain: {
+    params: {
+      to: z18.array(z18.any()).length(0).optional(),
+      from: z18.array(z18.any()).length(0).optional()
+    },
+    result: {
+      from: z18.any(),
+      to: z18.any()
+    }
+  }
+};
+
+// src/types/schema/AllRpcSchemas.ts
+var AllRpcSchemas = {
+  ...XyoProviderRpcSchemas,
+  ...XyoRunnerRpcSchemas,
+  ...XyoSignerRpcSchemas,
+  ...XyoViewerRpcSchemas,
+  ...XyoWalletRpcSchemas
+};
+
+// src/types/schema/createRequestSchema.ts
+import { z as z19 } from "zod";
+var createRequestSchema = /* @__PURE__ */ __name((methodName, paramsSchema = z19.undefined()) => z19.object({
+  id: z19.union([
+    z19.string(),
+    z19.number()
+  ]),
+  jsonrpc: z19.literal(jsonrpc),
+  method: z19.literal(methodName),
+  params: paramsSchema
+}), "createRequestSchema");
+
+// src/types/schema/createResponseSchema.ts
+import { z as z20 } from "zod";
+var createResponseSchema = /* @__PURE__ */ __name((resultSchema = z20.undefined()) => z20.object({
+  id: z20.union([
+    z20.string(),
+    z20.number()
+  ]),
+  jsonrpc: z20.literal(jsonrpc),
+  result: resultSchema
+}), "createResponseSchema");
+
+// src/engine/rpcMethodHandlersFromRunner.ts
+var rpcMethodHandlersFromRunner = /* @__PURE__ */ __name((runner) => {
+  return {
+    xyoRunner_broadcastTransaction: /* @__PURE__ */ __name((params) => runner.broadcastTransaction(...params ?? []), "xyoRunner_broadcastTransaction")
+  };
+}, "rpcMethodHandlersFromRunner");
+
+// src/engine/rpcMethodHandlersFromSigner.ts
+var rpcMethodHandlersFromSigner = /* @__PURE__ */ __name((signer) => {
+  return {
+    xyoSigner_address: /* @__PURE__ */ __name((params) => signer.address(...params ?? []), "xyoSigner_address"),
+    xyoSigner_createSignedTransaction: /* @__PURE__ */ __name((params) => signer.createSignedTransaction(...params ?? []), "xyoSigner_createSignedTransaction")
+  };
+}, "rpcMethodHandlersFromSigner");
+
+// src/engine/rpcMethodHandlersFromViewer.ts
+var rpcMethodHandlersFromViewer = /* @__PURE__ */ __name((viewer) => {
+  return {
+    xyoViewer_accountBalance: /* @__PURE__ */ __name((params) => viewer.accountBalance(...params ?? []), "xyoViewer_accountBalance"),
+    xyoViewer_blockByHash: /* @__PURE__ */ __name((params) => viewer.blockByHash(...params ?? []), "xyoViewer_blockByHash"),
+    xyoViewer_blockByNumber: /* @__PURE__ */ __name((params) => viewer.blockByNumber(...params ?? []), "xyoViewer_blockByNumber"),
+    xyoViewer_blocksByHash: /* @__PURE__ */ __name((params) => viewer.blocksByHash(...params ?? []), "xyoViewer_blocksByHash"),
+    xyoViewer_chainId: /* @__PURE__ */ __name((params) => viewer.chainId(...params ?? []), "xyoViewer_chainId"),
+    xyoViewer_currentBlock: /* @__PURE__ */ __name((params) => viewer.currentBlock(...params ?? []), "xyoViewer_currentBlock"),
+    xyoViewer_currentBlockHash: /* @__PURE__ */ __name((params) => viewer.currentBlockHash(...params ?? []), "xyoViewer_currentBlockHash"),
+    xyoViewer_currentBlockNumber: /* @__PURE__ */ __name((params) => viewer.currentBlockNumber(...params ?? []), "xyoViewer_currentBlockNumber"),
+    xyoViewer_transactionByBlockHashAndIndex: /* @__PURE__ */ __name((params) => viewer.transactionByBlockHashAndIndex(...params ?? []), "xyoViewer_transactionByBlockHashAndIndex"),
+    xyoViewer_transactionByBlockNumberAndIndex: /* @__PURE__ */ __name((params) => viewer.transactionByBlockNumberAndIndex(...params ?? []), "xyoViewer_transactionByBlockNumberAndIndex"),
+    xyoViewer_transactionByHash: /* @__PURE__ */ __name((params) => viewer.transactionByHash(...params ?? []), "xyoViewer_transactionByHash")
+  };
+}, "rpcMethodHandlersFromViewer");
+
+// src/engine/rpcMethodHandlersFromWallet.ts
+var rpcMethodHandlersFromWallet = /* @__PURE__ */ __name((wallet) => {
+  return {
+    xyoWallet_accounts: /* @__PURE__ */ __name((params) => wallet.accounts(...params ?? []), "xyoWallet_accounts"),
+    xyoWallet_addChain: /* @__PURE__ */ __name((params) => wallet.addChain(...params ?? []), "xyoWallet_addChain"),
+    xyoWallet_chain: /* @__PURE__ */ __name((params) => wallet.chain(...params ?? []), "xyoWallet_chain"),
+    xyoWallet_chains: /* @__PURE__ */ __name((params) => wallet.chains(...params ?? []), "xyoWallet_chains"),
+    xyoWallet_permissions: /* @__PURE__ */ __name((params) => wallet.permissions(...params ?? []), "xyoWallet_permissions"),
+    xyoWallet_requestPermissions: /* @__PURE__ */ __name((params) => wallet.requestPermissions(...params ?? []), "xyoWallet_requestPermissions"),
+    xyoWallet_revokePermissions: /* @__PURE__ */ __name((params) => wallet.revokePermissions(...params ?? []), "xyoWallet_revokePermissions"),
+    xyoWallet_switchChain: /* @__PURE__ */ __name((params) => wallet.switchChain(...params ?? []), "xyoWallet_switchChain")
+  };
+}, "rpcMethodHandlersFromWallet");
+
+// src/engine/rpcMethodHandlersFromProvider.ts
+var rpcMethodHandlersFromProvider = /* @__PURE__ */ __name((provider) => {
+  const { runner, signer, viewer, wallet } = provider;
+  let result = {
+    xyoProvider_send: /* @__PURE__ */ __name((params) => provider.send(...params ?? []), "xyoProvider_send")
+  };
+  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;
+}, "rpcMethodHandlersFromProvider");
+
+// src/engine/rpcEngineFromProvider.ts
+var requestSchemas = {};
+var rpcEngineFromProvider = /* @__PURE__ */ __name((provider) => {
+  const engine = new JsonRpcEngine();
+  const handlers = rpcMethodHandlersFromProvider(provider);
+  engine.push(createAsyncMiddleware(async (req, res) => {
+    const method = req.method;
+    const handler = handlers[method];
+    const schema = AllRpcSchemas[method];
+    if (!schema || !handler) {
+      res.error = JsonRpcErrorCodes.MethodNotFound;
+      return;
+    }
+    let requestSchema = requestSchemas[method];
+    if (!requestSchema) {
+      requestSchema = createRequestSchema(method, schema.params.from);
+      requestSchemas[method] = requestSchema;
+    }
+    const parsed = requestSchema.safeParse(req);
+    if (!parsed.success) {
+      res.error = {
+        // Return invalid params error
+        ...JsonRpcErrorCodes.InvalidParams,
+        // with the specific validation error message
+        message: parsed.error.message
+      };
+      return;
+    }
+    const { params } = parsed.data;
+    const result = await handler(params);
+    res.result = schema.result.to.parse(result);
+  }));
+  return engine;
+}, "rpcEngineFromProvider");
+
+// src/provider/provider/MemoryXyoProvider.ts
+import { assertEx } from "@xylabs/assert";
+import { defaultFees } from "@xyo-network/xl1-protocol";
+var MemoryXyoProvider = class {
+  static {
+    __name(this, "MemoryXyoProvider");
+  }
+  _runner;
+  _signer;
+  _viewer;
+  _wallet;
+  constructor(params) {
+    this._runner = params?.runner;
+    this._signer = params?.signer;
+    this._viewer = params?.viewer;
+    this._wallet = params?.wallet;
+  }
+  get runner() {
+    return this._runner;
+  }
+  get signer() {
+    return this._signer;
+  }
+  get viewer() {
+    return this._viewer;
+  }
+  get wallet() {
+    return this._wallet;
+  }
+  async send(elevatedPayloads, additionalPayloads, chain, nbf, exp, from, fees) {
+    const chainValue = chain === void 0 ? await this._wallet?.chain() : chain;
+    if (chainValue === void 0) throw new Error("Failed to determine chain");
+    const nbfValue = nbf === void 0 ? await this._viewer?.currentBlockNumber() : nbf;
+    if (nbfValue === void 0) throw new Error("Failed to determine nbf");
+    const expValue = exp === void 0 ? nbfValue + 1e3 : exp;
+    const feesValue = fees === void 0 ? defaultFees : fees;
+    const fromValue = from === void 0 ? await this._signer?.address() : from;
+    if (fromValue === void 0) throw new Error("Failed to determine from address");
+    const signedTransaction = assertEx(await this._signer?.createSignedTransaction(chainValue, elevatedPayloads, additionalPayloads, nbfValue, expValue, feesValue, fromValue), () => "Failed to create transaction");
+    assertEx(await this.runner?.broadcastTransaction([
+      signedTransaction,
+      elevatedPayloads
+    ]), () => "Failed to broadcast transaction");
+    return signedTransaction;
+  }
+};
+
+// src/provider/runner/JsonRpcXyoRunner.ts
+var JsonRpcXyoRunner = class {
+  static {
+    __name(this, "JsonRpcXyoRunner");
+  }
+  transport;
+  constructor(transport) {
+    this.transport = transport;
+  }
+  async broadcastTransaction(transaction) {
+    return await this.transport.sendRequest("xyoRunner_broadcastTransaction", [
+      transaction
+    ]);
+  }
+};
+
+// src/provider/runner/MemoryXyoRunner.ts
+import { MemoryArchivist } from "@xyo-network/archivist-memory";
+import { flattenHydratedTransaction } from "@xyo-network/chain-protocol";
+import { PayloadBuilder } from "@xyo-network/payload-builder";
+var MemoryXyoRunner = class {
+  static {
+    __name(this, "MemoryXyoRunner");
+  }
+  _archivist;
+  async broadcastTransaction(transaction) {
+    const archivist = await this.getArchivist();
+    await archivist.insert(flattenHydratedTransaction(transaction));
+    return await PayloadBuilder.hash(transaction[0]);
+  }
+  async getArchivist() {
+    if (!this._archivist) {
+      this._archivist = await MemoryArchivist.create({
+        account: "random"
+      });
+    }
+    return this._archivist;
+  }
+};
+
+// src/provider/runner/NodeXyoRunner.ts
+import { assertEx as assertEx2 } from "@xylabs/assert";
+import { asArchivistInstance } from "@xyo-network/archivist-model";
+import { flattenHydratedTransaction as flattenHydratedTransaction2 } from "@xyo-network/chain-protocol";
+import { PayloadBuilder as PayloadBuilder2 } from "@xyo-network/payload-builder";
+var NodeXyoRunner = class {
+  static {
+    __name(this, "NodeXyoRunner");
+  }
+  // TODO: Make configurable with defaults
+  node;
+  pendingArchivistPath = "XYOChain:Pending:PendingTransactions";
+  _pendingArchivist;
+  constructor(node) {
+    this.node = node;
+  }
+  async broadcastTransaction(transaction) {
+    const pendingArchivist = await this.getPendingArchivist();
+    await pendingArchivist.insert(flattenHydratedTransaction2(transaction));
+    return await PayloadBuilder2.hash(transaction[0]);
+  }
+  getArchivist = /* @__PURE__ */ __name(async (identifier) => {
+    const diviner = await this.node.resolve(identifier);
+    return assertEx2(asArchivistInstance(diviner), () => `Error: Could not resolve ${identifier} to an archivist instance`);
+  }, "getArchivist");
+  getPendingArchivist = /* @__PURE__ */ __name(async () => {
+    if (this._pendingArchivist) return this._pendingArchivist;
+    this._pendingArchivist = await this.getArchivist(this.pendingArchivistPath);
+    return this._pendingArchivist;
+  }, "getPendingArchivist");
+};
+
+// src/provider/signer/JsonRpcXyoSigner.ts
+var JsonRpcXyoSigner = class {
+  static {
+    __name(this, "JsonRpcXyoSigner");
+  }
+  transport;
+  constructor(transport) {
+    this.transport = transport;
+  }
+  async address() {
+    return await this.transport.sendRequest("xyoSigner_address");
+  }
+  async createSignedTransaction(chain, elevatedPayloads, additionalPayloads, nbf, exp, fees, from) {
+    return await this.transport.sendRequest("xyoSigner_createSignedTransaction", [
+      chain,
+      elevatedPayloads,
+      additionalPayloads,
+      nbf,
+      exp,
+      fees,
+      from
+    ]);
+  }
+};
+
+// src/provider/signer/MemoryXyoSigner.ts
+import { buildTransaction } from "@xyo-network/xl1-protocol";
+var MemoryXyoSigner = class {
+  static {
+    __name(this, "MemoryXyoSigner");
+  }
+  _account;
+  constructor(account) {
+    this._account = account;
+  }
+  address() {
+    return this._account.address;
+  }
+  async createSignedTransaction(chain, elevatedPayloads, additionalPayloads, nbf, exp, fees, from) {
+    const fromAddress = from ?? this._account.address;
+    const transaction = await buildTransaction(chain, elevatedPayloads, additionalPayloads, this._account, nbf, exp, fromAddress, fees);
+    return transaction[0];
+  }
+};
+
+// src/provider/viewer/JsonRpcXyoViewer.ts
+var JsonRpcXyoViewer = class {
+  static {
+    __name(this, "JsonRpcXyoViewer");
+  }
+  transport;
+  constructor(transport) {
+    this.transport = transport;
+  }
+  async accountBalance(address, blockNumber, full) {
+    return await this.transport.sendRequest("xyoViewer_accountBalance", [
+      address,
+      blockNumber,
+      full
+    ]);
+  }
+  async blockByHash(hash) {
+    return await this.transport.sendRequest("xyoViewer_blockByHash", [
+      hash
+    ]);
+  }
+  async blockByNumber(blockNumber) {
+    return await this.transport.sendRequest("xyoViewer_blockByNumber", [
+      blockNumber
+    ]);
+  }
+  async blocksByHash(hash, limit) {
+    return await this.transport.sendRequest("xyoViewer_blocksByHash", [
+      hash,
+      limit
+    ]);
+  }
+  async chainId() {
+    return await this.transport.sendRequest("xyoViewer_chainId");
+  }
+  async currentBlock() {
+    return await this.transport.sendRequest("xyoViewer_currentBlock");
+  }
+  async currentBlockHash() {
+    return await this.transport.sendRequest("xyoViewer_currentBlockHash");
+  }
+  async currentBlockNumber() {
+    return await this.transport.sendRequest("xyoViewer_currentBlockNumber");
+  }
+  async transactionByBlockHashAndIndex(blockHash, transactionIndex) {
+    return await this.transport.sendRequest("xyoViewer_transactionByBlockHashAndIndex", [
+      blockHash,
+      transactionIndex
+    ]);
+  }
+  async transactionByBlockNumberAndIndex(blockNumber, transactionIndex) {
+    return await this.transport.sendRequest("xyoViewer_transactionByBlockNumberAndIndex", [
+      blockNumber,
+      transactionIndex
+    ]);
+  }
+  async transactionByHash(transactionHash) {
+    return await this.transport.sendRequest("xyoViewer_transactionByHash", [
+      transactionHash
+    ]);
+  }
+};
+
+// src/provider/viewer/NodeXyoViewer.ts
+import { filterAs } from "@xylabs/array";
+import { assertEx as assertEx3 } from "@xylabs/assert";
+import { exists } from "@xylabs/exists";
+import { asAddress } from "@xylabs/hex";
+import { hexToBigInt as hexToBigInt2 } from "@xylabs/hex";
+import { asArchivistInstance as asArchivistInstance2 } from "@xyo-network/archivist-model";
+import { BoundWitnessSchema as BoundWitnessSchema2 } from "@xyo-network/boundwitness-model";
+import { analyzeChain, BalanceAnalyzer, findMostRecentBlock, hydrateBlock, hydrateTransaction, isChainSummaryBalances } from "@xyo-network/chain-protocol";
+import { asDivinerInstance } from "@xyo-network/diviner-model";
+import { asOptionalBlockBoundWitnessWithStorageMeta, asOptionalTransactionBoundWitnessWithStorageMeta } from "@xyo-network/xl1-model";
+var WindowLimit = 1e3;
+var WindowLimitBigInt = BigInt(WindowLimit);
+var NodeXyoViewer = class {
+  static {
+    __name(this, "NodeXyoViewer");
+  }
+  // TODO: Make configurable with defaults
+  finalizedArchivistPath = "XYOChain:Chain:Finalized";
+  headValidationDivinerPath = "XYOChain:Chain:HeadValidationDiviner";
+  node;
+  _chainId;
+  _finalizedArchivist;
+  _headValidationDiviner;
+  constructor(node) {
+    this.node = node;
+  }
+  async accountBalance(address, blockNumber, full) {
+    const head = await this.blockByNumber(blockNumber);
+    if (!head) {
+      throw new Error(`Error: Could not find block ${blockNumber}`);
+    }
+    const analysis = await analyzeChain(await this.getFinalizedArchivist(), [
+      new BalanceAnalyzer()
+    ], head, null, full ? -1n : WindowLimitBigInt);
+    const balances = assertEx3(analysis.find(isChainSummaryBalances)?.balances, () => "Failed to sync balances");
+    return balances[address] ? hexToBigInt2(balances[address]) : 0n;
+  }
+  async blockByHash(hash) {
+    const finalizedArchivist = await this.getFinalizedArchivist();
+    return await hydrateBlock(finalizedArchivist, hash);
+  }
+  async blockByNumber(blockNumber) {
+    const finalizedArchivist = await this.getFinalizedArchivist();
+    const result = await this.currentBlock();
+    let currentBlock = result[0];
+    if (currentBlock.block === blockNumber) return result;
+    if (blockNumber > currentBlock.block) throw new Error(`Error: Block number ${blockNumber} is greater than current block number ${currentBlock.block}`);
+    if (blockNumber < 0) throw new Error(`Error: Block number ${blockNumber} is less than 0`);
+    if (blockNumber - currentBlock.block > WindowLimit) throw new Error(`Error: Block number ${blockNumber} is too far in the past`);
+    do {
+      const { previous } = currentBlock;
+      if (previous === null) return null;
+      const nextBlock = asOptionalBlockBoundWitnessWithStorageMeta((await finalizedArchivist.get([
+        previous
+      ]))[0]);
+      if (!nextBlock) return null;
+      currentBlock = nextBlock;
+    } while (blockNumber != currentBlock.block);
+    return currentBlock.block === blockNumber ? await hydrateBlock(finalizedArchivist, currentBlock._hash) : null;
+  }
+  async blocksByHash(hash, limit = 10) {
+    assertEx3(limit > 0, () => "Error: limit must be greater than 0");
+    assertEx3(limit <= 100, () => "Error: limit must be less than 100");
+    const blocks = [];
+    let current = await this.blockByHash(hash);
+    while (current && blocks.length < limit) {
+      blocks.push(current);
+      const previousHash = current[0].previous;
+      if (!previousHash) break;
+      current = await this.blockByHash(previousHash);
+    }
+    return blocks;
+  }
+  async chainId() {
+    if (this._chainId) return this._chainId;
+    const headValidationDiviner = await this.getHeadValidationDiviner();
+    this._chainId = assertEx3(asAddress(headValidationDiviner.params.chainIdentification?.id), () => "HeadValidationDiviner.params.chainIdentification.id is required and must be an Address");
+    return await Promise.resolve(this._chainId);
+  }
+  async currentBlock() {
+    const finalizedArchivist = await this.getFinalizedArchivist();
+    return await hydrateBlock(finalizedArchivist, await this.currentBlockHash());
+  }
+  async currentBlockHash() {
+    const finalizedArchivist = await this.getFinalizedArchivist();
+    const block = assertEx3(await findMostRecentBlock(finalizedArchivist), () => "Error: Could not find most recent block");
+    return block._hash;
+  }
+  async currentBlockNumber() {
+    const finalizedArchivist = await this.getFinalizedArchivist();
+    const block = assertEx3(await findMostRecentBlock(finalizedArchivist), () => "Error: Could not find most recent block");
+    return block.block;
+  }
+  async transactionByBlockHashAndIndex(blockHash, transactionIndex = 0) {
+    assertEx3(transactionIndex >= 0, () => "Error: transactionIndex must be greater than or equal to 0");
+    try {
+      const block = await this.blockByHash(blockHash);
+      if (!block) return null;
+      const blockBoundWitnessIndexes = block[0].payload_schemas.map((schema, index) => schema === BoundWitnessSchema2 ? index : void 0).filter(exists);
+      const blockBoundWitnessHashes = new Set(blockBoundWitnessIndexes.map((index) => block[0].payload_hashes[index]));
+      const blockBoundWitnesses = block[1].filter((payload) => blockBoundWitnessHashes.has(payload._hash) || blockBoundWitnessHashes.has(payload._dataHash));
+      const blockTransactionBoundWitnesses = filterAs(blockBoundWitnesses, asOptionalTransactionBoundWitnessWithStorageMeta);
+      const transaction = blockTransactionBoundWitnesses.at(transactionIndex);
+      if (!transaction) return null;
+      return await this.transactionByHash(transaction._hash);
+    } catch {
+      return null;
+    }
+  }
+  async transactionByBlockNumberAndIndex(blockNumber, transactionIndex = 0) {
+    try {
+      const block = await this.blockByNumber(blockNumber);
+      if (!block) return null;
+      return await this.transactionByBlockHashAndIndex(block[0]._hash, transactionIndex);
+    } catch {
+      return null;
+    }
+  }
+  async transactionByHash(transactionHash) {
+    try {
+      const finalizedArchivist = await this.getFinalizedArchivist();
+      return await hydrateTransaction(finalizedArchivist, transactionHash);
+    } catch {
+      return null;
+    }
+  }
+  getArchivist = /* @__PURE__ */ __name(async (identifier) => {
+    const diviner = await this.node.resolve(identifier);
+    return assertEx3(asArchivistInstance2(diviner), () => `Error: Could not resolve ${identifier} to an archivist instance`);
+  }, "getArchivist");
+  getDiviner = /* @__PURE__ */ __name(async (identifier) => {
+    const diviner = await this.node.resolve(identifier);
+    return assertEx3(asDivinerInstance(diviner), () => `Error: Could not resolve ${identifier} to a diviner instance`);
+  }, "getDiviner");
+  getFinalizedArchivist = /* @__PURE__ */ __name(async () => {
+    if (this._finalizedArchivist) return this._finalizedArchivist;
+    this._finalizedArchivist = await this.getArchivist(this.finalizedArchivistPath);
+    return this._finalizedArchivist;
+  }, "getFinalizedArchivist");
+  getHeadValidationDiviner = /* @__PURE__ */ __name(async () => {
+    if (this._headValidationDiviner) return this._headValidationDiviner;
+    this._headValidationDiviner = await this.getDiviner(this.headValidationDivinerPath);
+    return this._headValidationDiviner;
+  }, "getHeadValidationDiviner");
+};
+
+// src/provider/wallet/JsonRpcXyoWallet.ts
+var JsonRpcXyoWallet = class {
+  static {
+    __name(this, "JsonRpcXyoWallet");
+  }
+  transport;
+  constructor(transport) {
+    this.transport = transport;
+  }
+  async accounts() {
+    return await this.transport.sendRequest("xyoWallet_accounts");
+  }
+  async addChain(chain, name) {
+    return await this.transport.sendRequest("xyoWallet_addChain", [
+      chain,
+      name
+    ]);
+  }
+  async chain() {
+    return await this.transport.sendRequest("xyoWallet_chain");
+  }
+  async chains() {
+    return await this.transport.sendRequest("xyoWallet_chains");
+  }
+  async permissions() {
+    return await this.transport.sendRequest("xyoWallet_permissions");
+  }
+  async requestPermissions(permissions) {
+    return await this.transport.sendRequest("xyoWallet_requestPermissions", [
+      permissions
+    ]);
+  }
+  async revokePermissions(permissions) {
+    return await this.transport.sendRequest("xyoWallet_revokePermissions", [
+      permissions
+    ]);
+  }
+  async switchChain(chain) {
+    return await this.transport.sendRequest("xyoWallet_switchChain", [
+      chain
+    ]);
+  }
+};
+
+// src/provider/wallet/MemoryXyoWallet.ts
+import { assertEx as assertEx4 } from "@xylabs/assert";
+var MemoryXyoWallet = class {
+  static {
+    __name(this, "MemoryXyoWallet");
+  }
+  _account;
+  _chain;
+  _chains = {};
+  constructor(account) {
+    this._account = account;
+  }
+  accounts() {
+    return [
+      this._account.address
+    ];
+  }
+  addChain(chain, name) {
+    this._chains[chain] = name;
+    return this.chains();
+  }
+  chain() {
+    return assertEx4(this._chain, () => "Chain not set");
+  }
+  chains() {
+    return this._chains;
+  }
+  permissions() {
+    throw new Error("Method not implemented.");
+  }
+  requestPermissions(_permissions) {
+    throw new Error("Method not implemented.");
+  }
+  revokePermissions(_permissions) {
+    throw new Error("Method not implemented.");
+  }
+  switchChain(chain) {
+    if (this._chains[chain]) {
+      this._chain = chain;
+    } else {
+      throw new Error(`Chain ${chain} not found in wallet`);
+    }
+  }
+};
+
+// src/transport/HttpRpcTransport.ts
+import { AxiosJson } from "@xylabs/axios";
+import { v4 } from "uuid";
+var HttpRpcTransport = class {
+  static {
+    __name(this, "HttpRpcTransport");
+  }
+  _rpcUrl;
+  _schemas;
+  constructor(rpcUrl, schemas) {
+    this._rpcUrl = rpcUrl;
+    this._schemas = schemas;
+  }
+  async sendRequest(method, params) {
+    return await this.callRpc(this._rpcUrl, this._schemas, method, params);
+  }
+  async callRpc(url, schemas, method, params) {
+    const id = v4();
+    const body = {
+      jsonrpc,
+      id,
+      method
+    };
+    if (params) {
+      body.params = schemas[method].params.to.parse(params);
+    }
+    const res = await new AxiosJson().post(url, body);
+    const json = res.data;
+    if (!json || json.error) {
+      throw new Error(json.error.message);
+    }
+    return schemas[method].result.from.parse(json.result);
+  }
+};
+
+// src/transport/MemoryRpcTransport.ts
+import { v4 as v42 } from "uuid";
+var MemoryRpcTransport = class {
+  static {
+    __name(this, "MemoryRpcTransport");
+  }
+  _rpcEngine;
+  _schemas;
+  requestSchemas = {};
+  responseSchemas = {};
+  constructor(rpcEngine, schemas = AllRpcSchemas) {
+    this._rpcEngine = rpcEngine;
+    this._schemas = schemas;
+  }
+  async sendRequest(method, params) {
+    const schema = this._schemas[method];
+    let requestSchema = this.requestSchemas[method];
+    if (!requestSchema) {
+      requestSchema = createRequestSchema(method, schema.params.to);
+      this.requestSchemas[method] = requestSchema;
+    }
+    const req = {
+      jsonrpc,
+      id: v42(),
+      method,
+      params
+    };
+    const request = requestSchema.parse(req);
+    const response = await this._rpcEngine.handle(request);
+    let responseSchema = this.responseSchemas[method];
+    if (!responseSchema) {
+      responseSchema = createResponseSchema(schema.result.from);
+      this.responseSchemas[method] = responseSchema;
+    }
+    return responseSchema.parse(response)?.result;
+  }
+};
+export {
+  AllRpcSchemas,
+  HttpRpcTransport,
+  JsonRpcErrorCodes,
+  JsonRpcXyoRunner,
+  JsonRpcXyoSigner,
+  JsonRpcXyoViewer,
+  JsonRpcXyoWallet,
+  MemoryRpcTransport,
+  MemoryXyoProvider,
+  MemoryXyoRunner,
+  MemoryXyoSigner,
+  MemoryXyoWallet,
+  NodeXyoRunner,
+  NodeXyoViewer,
+  XyoProviderRpcSchemas,
+  XyoRunnerRpcSchemas,
+  XyoSignerRpcSchemas,
+  XyoViewerRpcSchemas,
+  XyoWalletRpcSchemas,
+  createRequestSchema,
+  createResponseSchema,
+  jsonrpc,
+  rpcEngineFromProvider
+};
+//# sourceMappingURL=index.mjs.map