@xyo-network/xl1-rpc 1.16.1 → 1.16.2

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

@@ -1,34 +1,12 @@
 import * as z from 'zod';
 export declare const AttoZod: z.ZodBigInt;
-export declare const JsonToAttoZod: z.ZodPipe<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<Lowercase<string>, {
-    readonly __hex: true;
-}>, string>>, z.ZodTransform<bigint, import("@xylabs/typeof").Brand<Lowercase<string>, {
-    readonly __hex: true;
-}>>>, z.ZodTransform<import("@xyo-network/xl1-protocol").AttoXL1, bigint>>;
-export declare const AttoToJsonZod: z.ZodPipe<z.ZodBigInt, z.ZodTransform<import("@xylabs/typeof").Brand<Lowercase<string>, {
-    readonly __hex: true;
-}>, bigint>>;
+export declare const JsonToAttoZod: z.ZodPipe<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hex, string>>, z.ZodTransform<bigint, import("@xylabs/hex").Hex>>, z.ZodTransform<import("@xyo-network/xl1-protocol").AttoXL1, bigint>>;
+export declare const AttoToJsonZod: z.ZodPipe<z.ZodBigInt, z.ZodTransform<import("@xylabs/hex").Hex, bigint>>;
 export declare const TransactionFeesHexZod: z.ZodObject<{
-    base: z.ZodType<import("@xylabs/typeof").Brand<Lowercase<string>, {
-        readonly __hex: true;
-    }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<Lowercase<string>, {
-        readonly __hex: true;
-    }>, unknown>>;
-    gasLimit: z.ZodType<import("@xylabs/typeof").Brand<Lowercase<string>, {
-        readonly __hex: true;
-    }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<Lowercase<string>, {
-        readonly __hex: true;
-    }>, unknown>>;
-    gasPrice: z.ZodType<import("@xylabs/typeof").Brand<Lowercase<string>, {
-        readonly __hex: true;
-    }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<Lowercase<string>, {
-        readonly __hex: true;
-    }>, unknown>>;
-    priority: z.ZodType<import("@xylabs/typeof").Brand<Lowercase<string>, {
-        readonly __hex: true;
-    }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<Lowercase<string>, {
-        readonly __hex: true;
-    }>, unknown>>;
+    base: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hex, string>>;
+    gasLimit: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hex, string>>;
+    gasPrice: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hex, string>>;
+    priority: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hex, string>>;
 }, z.core.$strip>;
 export type TransactionFeesHexZodType = z.infer<typeof TransactionFeesHexZod>;
 export declare const TransactionFeesBigIntZod: z.ZodObject<{
@@ -39,44 +17,20 @@ export declare const TransactionFeesBigIntZod: z.ZodObject<{
 }, z.core.$strip>;
 export type TransactionFeesBigIntZodType = z.infer<typeof TransactionFeesBigIntZod>;
 export declare const TransactionFeesJsonToBigIntZod: z.ZodPipe<z.ZodObject<{
-    base: z.ZodType<import("@xylabs/typeof").Brand<Lowercase<string>, {
-        readonly __hex: true;
-    }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<Lowercase<string>, {
-        readonly __hex: true;
-    }>, unknown>>;
-    gasLimit: z.ZodType<import("@xylabs/typeof").Brand<Lowercase<string>, {
-        readonly __hex: true;
-    }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<Lowercase<string>, {
-        readonly __hex: true;
-    }>, unknown>>;
-    gasPrice: z.ZodType<import("@xylabs/typeof").Brand<Lowercase<string>, {
-        readonly __hex: true;
-    }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<Lowercase<string>, {
-        readonly __hex: true;
-    }>, unknown>>;
-    priority: z.ZodType<import("@xylabs/typeof").Brand<Lowercase<string>, {
-        readonly __hex: true;
-    }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<Lowercase<string>, {
-        readonly __hex: true;
-    }>, unknown>>;
+    base: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hex, string>>;
+    gasLimit: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hex, string>>;
+    gasPrice: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hex, string>>;
+    priority: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hex, string>>;
 }, z.core.$strip>, z.ZodTransform<{
     base: bigint;
     gasLimit: bigint;
     gasPrice: bigint;
     priority: bigint;
 }, {
-    base: import("@xylabs/typeof").Brand<Lowercase<string>, {
-        readonly __hex: true;
-    }>;
-    gasLimit: import("@xylabs/typeof").Brand<Lowercase<string>, {
-        readonly __hex: true;
-    }>;
-    gasPrice: import("@xylabs/typeof").Brand<Lowercase<string>, {
-        readonly __hex: true;
-    }>;
-    priority: import("@xylabs/typeof").Brand<Lowercase<string>, {
-        readonly __hex: true;
-    }>;
+    base: import("@xylabs/hex").Hex;
+    gasLimit: import("@xylabs/hex").Hex;
+    gasPrice: import("@xylabs/hex").Hex;
+    priority: import("@xylabs/hex").Hex;
 }>>;
 export declare const TransactionFeesBigIntToJsonZod: z.ZodPipe<z.ZodObject<{
     base: z.ZodBigInt;
@@ -84,18 +38,10 @@ export declare const TransactionFeesBigIntToJsonZod: z.ZodPipe<z.ZodObject<{
     gasPrice: z.ZodBigInt;
     priority: z.ZodBigInt;
 }, z.core.$strip>, z.ZodTransform<{
-    base: import("@xylabs/typeof").Brand<Lowercase<string>, {
-        readonly __hex: true;
-    }>;
-    gasLimit: import("@xylabs/typeof").Brand<Lowercase<string>, {
-        readonly __hex: true;
-    }>;
-    gasPrice: import("@xylabs/typeof").Brand<Lowercase<string>, {
-        readonly __hex: true;
-    }>;
-    priority: import("@xylabs/typeof").Brand<Lowercase<string>, {
-        readonly __hex: true;
-    }>;
+    base: import("@xylabs/hex").Hex;
+    gasLimit: import("@xylabs/hex").Hex;
+    gasPrice: import("@xylabs/hex").Hex;
+    priority: import("@xylabs/hex").Hex;
 }, {
     base: bigint;
     gasLimit: bigint;

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

@@ -1 +1 @@
-{"version":3,"file":"TransactionFees.d.ts","sourceRoot":"","sources":["../../../../../src/types/schema/common/TransactionFees.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAExB,eAAO,MAAM,OAAO,aAAa,CAAA;AACjC,eAAO,MAAM,aAAa;;;;0EAA+C,CAAA;AAEzE,eAAO,MAAM,aAAa;;YAAkB,CAAA;AAE5C,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;iBAKhC,CAAA;AAEF,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAA;AAE7E,eAAO,MAAM,wBAAwB;;;;;iBAKnC,CAAA;AAEF,MAAM,MAAM,4BAA4B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAA;AAEnF,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAKxC,CAAA;AAEH,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;GAKxC,CAAA;AAEH,MAAM,MAAM,kCAAkC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,8BAA8B,CAAC,CAAA;AAC/F,MAAM,MAAM,kCAAkC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,8BAA8B,CAAC,CAAA"}
+{"version":3,"file":"TransactionFees.d.ts","sourceRoot":"","sources":["../../../../../src/types/schema/common/TransactionFees.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAExB,eAAO,MAAM,OAAO,aAAa,CAAA;AACjC,eAAO,MAAM,aAAa,yNAA+C,CAAA;AAEzE,eAAO,MAAM,aAAa,2EAAkB,CAAA;AAE5C,eAAO,MAAM,qBAAqB;;;;;iBAKhC,CAAA;AAEF,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAA;AAE7E,eAAO,MAAM,wBAAwB;;;;;iBAKnC,CAAA;AAEF,MAAM,MAAM,4BAA4B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAA;AAEnF,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;GAKxC,CAAA;AAEH,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;GAKxC,CAAA;AAEH,MAAM,MAAM,kCAAkC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,8BAA8B,CAAC,CAAA;AAC/F,MAAM,MAAM,kCAAkC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,8BAA8B,CAAC,CAAA"}

package/dist/node/types/schema/common/Transfer.d.ts

@@ -3,60 +3,36 @@ export declare const TransferFieldsZod: z.ZodObject<{
     $opCodes: z.ZodOptional<z.ZodArray<z.ZodString>>;
     context: z.ZodOptional<z.ZodObject<{}, z.z.core.$strip>>;
     epoch: z.ZodNumber;
-    from: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-        readonly __hex: true;
-    }>, {
+    from: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
         readonly __address: true;
     }>, string>>;
-    transfers: z.ZodRecord<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-        readonly __hex: true;
-    }>, {
+    transfers: z.ZodRecord<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
         readonly __address: true;
-    }>, string>>, z.ZodType<import("@xylabs/typeof").Brand<Lowercase<string>, {
-        readonly __hex: true;
-    }>, unknown, z.z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<Lowercase<string>, {
-        readonly __hex: true;
-    }>, unknown>>>;
+    }>, string>>, z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hex, string>>>;
 }, z.z.core.$strip>;
 export declare const TransferZod: z.ZodObject<{
     schema: z.ZodLiteral<"network.xyo.transfer">;
     $opCodes: z.ZodOptional<z.ZodArray<z.ZodString>>;
     context: z.ZodOptional<z.ZodObject<{}, z.z.core.$strip>>;
     epoch: z.ZodNumber;
-    from: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-        readonly __hex: true;
-    }>, {
+    from: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
         readonly __address: true;
     }>, string>>;
-    transfers: z.ZodRecord<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-        readonly __hex: true;
-    }>, {
+    transfers: z.ZodRecord<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
         readonly __address: true;
-    }>, string>>, z.ZodType<import("@xylabs/typeof").Brand<Lowercase<string>, {
-        readonly __hex: true;
-    }>, unknown, z.z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<Lowercase<string>, {
-        readonly __hex: true;
-    }>, unknown>>>;
+    }>, string>>, z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hex, string>>>;
 }, z.z.core.$strict>;
 export declare const TransferZodWithStorageMeta: z.ZodObject<{
     schema: z.ZodLiteral<"network.xyo.transfer">;
     $opCodes: z.ZodOptional<z.ZodArray<z.ZodString>>;
     context: z.ZodOptional<z.ZodObject<{}, z.z.core.$strip>>;
     epoch: z.ZodNumber;
-    from: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-        readonly __hex: true;
-    }>, {
+    from: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
         readonly __address: true;
     }>, string>>;
-    transfers: z.ZodRecord<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-        readonly __hex: true;
-    }>, {
+    transfers: z.ZodRecord<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
         readonly __address: true;
-    }>, string>>, z.ZodType<import("@xylabs/typeof").Brand<Lowercase<string>, {
-        readonly __hex: true;
-    }>, unknown, z.z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<Lowercase<string>, {
-        readonly __hex: true;
-    }>, unknown>>>;
+    }>, string>>, z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/hex").Hex, string>>>;
     _hash: z.ZodPipe<z.ZodType<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
         readonly __hex: true;
     }>, {

package/dist/node/types/schema/common/Transfer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Transfer.d.ts","sourceRoot":"","sources":["../../../../../src/types/schema/common/Transfer.ts"],"names":[],"mappings":"AAGA,OAAO,CAAC,MAAM,KAAK,CAAA;AAInB,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;mBAM5B,CAAA;AAEF,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;oBAA2E,CAAA;AACnG,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAA2C,CAAA"}
+{"version":3,"file":"Transfer.d.ts","sourceRoot":"","sources":["../../../../../src/types/schema/common/Transfer.ts"],"names":[],"mappings":"AAGA,OAAO,CAAC,MAAM,KAAK,CAAA;AAInB,eAAO,MAAM,iBAAiB;;;;;;;;;;mBAM5B,CAAA;AAEF,eAAO,MAAM,WAAW;;;;;;;;;;;oBAA2E,CAAA;AACnG,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAA2C,CAAA"}

package/dist/node/types/schema/common/TransferPair.d.ts

@@ -1,11 +1,7 @@
 import z from 'zod';
-export declare const TransferPairZod: z.ZodTuple<[z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-    readonly __hex: true;
-}>, {
+export declare const TransferPairZod: z.ZodTuple<[z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
     readonly __address: true;
-}>, string>>, z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-    readonly __hex: true;
-}>, {
+}>, string>>, z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/hex").Hex, {
     readonly __address: true;
 }>, string>>], null>;
 //# sourceMappingURL=TransferPair.d.ts.map

package/dist/node/types/schema/common/TransferPair.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TransferPair.d.ts","sourceRoot":"","sources":["../../../../../src/types/schema/common/TransferPair.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,KAAK,CAAA;AAInB,eAAO,MAAM,eAAe;;;;;;;;oBAE1B,CAAA"}
+{"version":3,"file":"TransferPair.d.ts","sourceRoot":"","sources":["../../../../../src/types/schema/common/TransferPair.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,KAAK,CAAA;AAInB,eAAO,MAAM,eAAe;;;;oBAE1B,CAAA"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "http://json.schemastore.org/package.json",
   "name": "@xyo-network/xl1-rpc",
-  "version": "1.16.1",
+  "version": "1.16.2",
   "description": "XYO Layer One API",
   "homepage": "https://xylabs.com",
   "bugs": {
@@ -56,24 +56,21 @@
   },
   "dependencies": {
     "@metamask/json-rpc-engine": "~10.1.1",
-    "@xylabs/arraybuffer": "~5.0.21",
-    "@xylabs/assert": "~5.0.21",
-    "@xylabs/axios": "~5.0.21",
-    "@xylabs/exists": "~5.0.21",
-    "@xylabs/hex": "~5.0.21",
-    "@xylabs/promise": "~5.0.21",
-    "@xylabs/typeof": "~5.0.21",
+    "@xylabs/assert": "~5.0.22",
+    "@xylabs/axios": "~5.0.22",
+    "@xylabs/hex": "~5.0.22",
+    "@xylabs/promise": "~5.0.22",
+    "@xylabs/typeof": "~5.0.22",
     "@xyo-network/account-model": "~5.1.18",
     "@xyo-network/archivist-memory": "~5.1.18",
     "@xyo-network/archivist-model": "~5.1.18",
     "@xyo-network/boundwitness-model": "~5.1.18",
-    "@xyo-network/hash": "~5.1.18",
     "@xyo-network/module-model": "~5.1.18",
     "@xyo-network/node-model": "~5.1.18",
     "@xyo-network/payload-builder": "~5.1.18",
     "@xyo-network/payload-model": "~5.1.18",
-    "@xyo-network/xl1-protocol": "~1.13.0",
-    "@xyo-network/xl1-protocol-sdk": "~1.16.1",
+    "@xyo-network/xl1-protocol": "~1.13.1",
+    "@xyo-network/xl1-protocol-sdk": "~1.16.2",
     "axios": "~1.13.2",
     "uuid": "~13.0.0",
     "zod": "~4.1.12"
@@ -81,13 +78,13 @@
   "devDependencies": {
     "@metamask/utils": "~11.8.1",
     "@types/node": "~24.10.0",
-    "@xylabs/logger": "~5.0.21",
-    "@xylabs/object": "~5.0.21",
+    "@xylabs/logger": "~5.0.22",
+    "@xylabs/object": "~5.0.22",
     "@xylabs/ts-scripts-yarn3": "~7.2.8",
     "@xylabs/tsconfig": "~7.2.8",
-    "@xylabs/vitest-extended": "~5.0.21",
+    "@xylabs/vitest-extended": "~5.0.22",
     "@xyo-network/account": "~5.1.18",
-    "@xyo-network/chain-protocol": "~1.16.1",
+    "@xyo-network/chain-protocol": "~1.16.2",
     "@xyo-network/wallet": "~5.1.18",
     "dotenv": "~17.2.3",
     "eslint": "^9.39.1",

package/src/provider/connection/spec/XyoConnection.spec.ts

@@ -1,4 +1,4 @@
-import type { XyoConnection } from '@xyo-network/xl1-protocol-sdk'
+import { SimpleXyoRunner, type XyoConnection } from '@xyo-network/xl1-protocol-sdk'
 import {
   beforeAll, describe, expect, it,
 } from 'vitest'
@@ -6,14 +6,13 @@ import {
 import { rpcEngineFromConnection } from '../../../engine-node/index.ts'
 import { MemoryRpcTransport } from '../../../transport/index.ts'
 import { AllRpcSchemas } from '../../../types/index.ts'
-import { MemoryXyoRunner } from '../../runner/index.ts'
 import { JsonRpcNetworkStakeViewer, JsonRpcXyoViewer } from '../../viewer/index.ts'
 import { XyoBaseConnection } from '../XyoBaseConnection.ts'
 
 describe('RpcEngine - XyoProvider', () => {
   let sut: XyoConnection
   beforeAll(() => {
-    const runner = new MemoryXyoRunner()
+    const runner = new SimpleXyoRunner()
     const connection = new XyoBaseConnection({ runner })
     const engine = rpcEngineFromConnection(connection)
     const transport = new MemoryRpcTransport(engine, AllRpcSchemas)

package/src/provider/datalake/JsonRpcDataLakeViewerMethods.ts

@@ -5,15 +5,15 @@ import type { DataLakeViewerRpcSchemas } from '../../types/index.ts'
 import { JsonRpcViewer } from '../viewer/index.ts'
 
 export class JsonRpcDataLakeViewerMethods extends JsonRpcViewer<typeof DataLakeViewerRpcSchemas> implements DataLakeViewerMethods {
-  get(id: unknown): Promise<Payload | ArrayBuffer | undefined> {
+  get(_id: unknown): Promise<Payload | ArrayBuffer | undefined> {
     throw new Error('Method not implemented.')
   }
 
-  getMany(id: unknown): Promise<(Payload | ArrayBuffer)[]> {
+  getMany(_id: unknown): Promise<(Payload | ArrayBuffer)[]> {
     throw new Error('Method not implemented.')
   }
 
-  has(id: unknown): Promise<boolean> {
+  has(_id: unknown): Promise<boolean> {
     throw new Error('Method not implemented.')
   }
 }

package/src/provider/index.ts

@@ -1,8 +1,5 @@
-export * from './client/index.ts'
 export * from './connection/index.ts'
 export * from './datalake/index.ts'
-export * from './gateway/index.ts'
-export * from './network/index.ts'
 export * from './permissions/index.ts'
 export * from './runner/index.ts'
 export * from './signer/index.ts'

package/src/provider/permissions/index.ts

@@ -1,3 +1 @@
-export * from './MemoryXyoPermissions.ts'
 export * from './RpcXyoPermissions.ts'
-export * from './store/index.ts'

package/src/provider/runner/index.ts

@@ -1,3 +1,2 @@
 export * from './JsonRpcXyoRunner.ts'
-export * from './MemoryXyoRunner.ts'
 export * from './NodeXyoRunner.ts'

package/src/provider/signer/JsonRpcXyoSigner.ts

@@ -1,6 +1,6 @@
 import type { Address } from '@xylabs/hex'
 import type {
-  SignedHydratedTransaction,
+  SignedHydratedTransactionWithHashMeta,
   UnsignedHydratedTransaction,
 } from '@xyo-network/xl1-protocol'
 import type { XyoSigner } from '@xyo-network/xl1-protocol-sdk'
@@ -19,7 +19,7 @@ export class RpcXyoSigner implements XyoSigner {
     return await this.transport.sendRequest('xyoSigner_address')
   }
 
-  async signTransaction(tx: UnsignedHydratedTransaction): Promise<SignedHydratedTransaction> {
+  async signTransaction(tx: UnsignedHydratedTransaction): Promise<SignedHydratedTransactionWithHashMeta> {
     const ret = await this.transport.sendRequest('xyoSigner_signTransaction', [tx])
     return ret
   }

package/src/provider/signer/index.ts

@@ -1,2 +1 @@
 export * from './JsonRpcXyoSigner.ts'
-export * from './MemoryXyoSigner.ts'

package/src/provider/signer/spec/RpcEngineXyoSigner.spec.ts

@@ -5,7 +5,7 @@ import { Account } from '@xyo-network/account'
 import type { ChainId } from '@xyo-network/xl1-protocol'
 import { defaultTransactionFees } from '@xyo-network/xl1-protocol'
 import type { XyoSigner } from '@xyo-network/xl1-protocol-sdk'
-import { buildUnsignedTransaction } from '@xyo-network/xl1-protocol-sdk'
+import { buildUnsignedTransaction, SimpleXyoSigner } from '@xyo-network/xl1-protocol-sdk'
 import {
   beforeAll, describe, expect, it,
 } from 'vitest'
@@ -16,14 +16,13 @@ import {
   createRequestSchema, JsonRpcErrorCodes, XyoSignerRpcSchemas,
 } from '../../../types/index.ts'
 import { RpcXyoSigner } from '../JsonRpcXyoSigner.ts'
-import { MemoryXyoSigner } from '../MemoryXyoSigner.ts'
 
 describe('RpcEngine - XyoSigner', () => {
   let sut: XyoSigner
   const chain = toAddress('2AAE728aFd1777b79c34D79c4523797F9D9965b0') as ChainId
   beforeAll(async () => {
     const account = await Account.random()
-    const signer = new MemoryXyoSigner(account)
+    const signer = new SimpleXyoSigner(account)
     const handlers = rpcMethodHandlersFromSigner(signer)
     const engine = new JsonRpcEngine()
     engine.push(

package/src/provider/viewer/JsonRpcXyoViewer.ts

@@ -188,7 +188,7 @@ export class JsonRpcXyoViewer implements XyoViewer {
     return asAttoXL1(await this.transport.sendRequest('xyoViewer_transferBalance', [address]))
   }
 
-  transferBalanceHistory(address: Address, range?: XL1BlockRange): Promise<TransferBalanceHistoryItem[]> {
+  transferBalanceHistory(_address: Address, _range?: XL1BlockRange): Promise<TransferBalanceHistoryItem[]> {
     throw new Error('Method not implemented.')
   }
 
@@ -196,7 +196,7 @@ export class JsonRpcXyoViewer implements XyoViewer {
     return asAttoXL1(await this.transport.sendRequest('xyoViewer_transferPairBalance', [pair]))
   }
 
-  transferPairBalanceHistory(pair: TransferPair): Promise<TransferBalanceHistoryItem[]> {
+  transferPairBalanceHistory(_pair: TransferPair): Promise<TransferBalanceHistoryItem[]> {
     throw new Error('Method not implemented.')
   }
 }

package/src/{provider/client/spec → spec}/MemoryXyoClient.spec.ts

@@ -1,43 +1,47 @@
 import type { AccountInstance } from '@xyo-network/account-model'
 import { HDWallet } from '@xyo-network/wallet'
 import type { GatewayName } from '@xyo-network/xl1-protocol'
-import type { XyoClient, XyoConnection } from '@xyo-network/xl1-protocol-sdk'
-import { ADDRESS_INDEX, generateXyoBaseWalletFromPhrase } from '@xyo-network/xl1-protocol-sdk'
+import type {
+  XyoClient, XyoConnection,
+  XyoGateway,
+  XyoPermissions,
+} from '@xyo-network/xl1-protocol-sdk'
+import {
+  ADDRESS_INDEX, generateXyoBaseWalletFromPhrase, MemoryPermissionsStore, SimpleXyoClient, SimpleXyoGateway,
+  SimpleXyoPermissions,
+  SimpleXyoSigner,
+} from '@xyo-network/xl1-protocol-sdk'
 import {
   beforeEach, describe, expect, it,
 } from 'vitest'
 
-import { HttpRpcXyoConnection } from '../../connection/index.ts'
-import { MemoryXyoGateway } from '../../gateway/index.ts'
-import { MemoryPermissionsStore, MemoryXyoPermissions } from '../../permissions/index.ts'
-import { MemoryXyoSigner } from '../../signer/index.ts'
-import { MemoryXyoClient } from '../MemoryXyoClient.ts'
+import { HttpRpcXyoConnection } from '../provider/connection/index.ts'
 
 describe('Client', () => {
   const endpoint = 'http://localhost:8080/rpc'
   const invoker = 'http://localhost:3000'
   // const dataLakeEndpoint = 'http://localhost:8080/chain/archivist'
   let account: AccountInstance
-  let signer: MemoryXyoSigner
+  let signer: SimpleXyoSigner
   let store
-  let permissions: MemoryXyoPermissions
+  let permissions: XyoPermissions
   let connection: XyoConnection
-  let gateway: MemoryXyoGateway
+  let gateway: XyoGateway
   let client: XyoClient
 
   beforeEach(async () => {
     const mnemonic = process.env.XL1_PRODUCER__MNEMONIC ?? HDWallet.generateMnemonic()
     const wallet = await generateXyoBaseWalletFromPhrase(mnemonic)
     account = await wallet.derivePath(ADDRESS_INDEX.XYO)
-    signer = new MemoryXyoSigner(account)
+    signer = new SimpleXyoSigner(account)
     store = new MemoryPermissionsStore(invoker)
-    permissions = new MemoryXyoPermissions(store)
+    permissions = new SimpleXyoPermissions(store)
     connection = new HttpRpcXyoConnection({
       endpoint,
       // storage: dataLakeEndpoint,
     })
-    gateway = new MemoryXyoGateway(signer, connection)
-    client = new MemoryXyoClient({ localhost: gateway }, permissions)
+    gateway = new SimpleXyoGateway(signer, connection)
+    client = new SimpleXyoClient({ localhost: gateway }, permissions)
   })
 
   describe('permissions', () => {
@@ -50,11 +54,11 @@ describe('Client', () => {
   describe('gateways', () => {
     describe('connection', () => {
       it('should be defined', () => {
-        const gateway = client.gateways['localhost' as GatewayName].connection()
+        const gateway = client.gateways['localhost' as GatewayName].connection
         expect(gateway).toBeDefined()
       })
       it('should allow retrieving the chain ID', async () => {
-        const chainId = await (await client.gateways['localhost' as GatewayName]?.connection())?.viewer?.chainId()
+        const chainId = await (await client.gateways['localhost' as GatewayName]?.connection)?.viewer?.chainId()
         expect(chainId).toBeDefined()
       })
     })

package/src/{provider/gateway/spec → spec}/MemoryXyoGateway.spec.ts

@@ -5,43 +5,45 @@ import type { AccountInstance } from '@xyo-network/account-model'
 import { PayloadBuilder } from '@xyo-network/payload-builder'
 import type { AnyPayload, Payload } from '@xyo-network/payload-model'
 import type { AllowedBlockPayload, SignedHydratedTransaction } from '@xyo-network/xl1-protocol'
-import { buildUnsignedTransaction } from '@xyo-network/xl1-protocol-sdk'
+import type { XyoGatewayRunner } from '@xyo-network/xl1-protocol-sdk'
+import {
+  buildUnsignedTransaction, SimpleXyoGateway, SimpleXyoGatewayRunner,
+  SimpleXyoSigner,
+} from '@xyo-network/xl1-protocol-sdk'
 import {
   beforeEach, describe, expect, it,
   vi,
 } from 'vitest'
 
-import { HttpRpcXyoConnection } from '../../connection/index.ts'
-import { MemoryXyoSigner } from '../../signer/index.ts'
-import { MemoryXyoGateway } from '../MemoryXyoGateway.ts'
+import { HttpRpcXyoConnection } from '../provider/connection/index.ts'
 
 describe('MemoryXyoGateway', () => {
   const endpoint = 'http://localhost:8080/rpc'
   // const dataLakeEndpoint = 'http://localhost:8080/chain/archivist'
   let account: AccountInstance
-  let signer: MemoryXyoSigner
+  let signer: SimpleXyoSigner
   let connection: HttpRpcXyoConnection
-  let sut: MemoryXyoGateway
+  let sut: XyoGatewayRunner
 
   beforeEach(async () => {
     account = await Account.random()
-    signer = new MemoryXyoSigner(account)
+    signer = new SimpleXyoSigner(account)
 
     connection = new HttpRpcXyoConnection({
       endpoint,
       // storage: dataLakeEndpoint,
     })
-    sut = new MemoryXyoGateway(signer, connection)
+    sut = new SimpleXyoGatewayRunner(new SimpleXyoGateway(signer, connection))
   })
 
   describe('connection', () => {
     it('should return the connection', () => {
-      expect(sut.connection()).toBeDefined()
+      expect(sut.connection).toBeDefined()
     })
   })
   describe('signer', () => {
     it('should return the signer', () => {
-      expect(sut.signer()).toBeDefined()
+      expect(sut.signer).toBeDefined()
     })
   })
   describe('submitTransaction', () => {
@@ -50,7 +52,7 @@ describe('MemoryXyoGateway', () => {
       const additionalPayloads: Payload[] = []
       const chainId = await connection.viewer?.chainId()
       const nbf = await connection.viewer?.currentBlockNumber() ?? 0
-      const signer = sut.signer()
+      const signer = sut.signer
       const signerAddress = await signer.address()
       expect(chainId).toBeDefined()
       if (chainId) {

package/src/types/schema/DataLakeViewerRpcSchema.ts

@@ -1,10 +1,9 @@
+import { HashZod } from '@xylabs/hex'
 import { PayloadZod } from '@xyo-network/payload-model'
 import * as z from 'zod'
 
 import type { DataLakeViewerRpcMethodName } from '../XyoDataLakeViewerRpc.ts'
-import {
-  ArrayBufferToJsonZod, HashZod, JsonToArrayBufferZod,
-} from './common/index.ts'
+import { ArrayBufferToJsonZod, JsonToArrayBufferZod } from './common/index.ts'
 import type { RpcSchemaMap } from './RpcSchemaMap.ts'
 
 export const DataLakeViewerRpcSchemas = {

package/src/types/schema/common/BlockBoundWitness.ts

@@ -1,4 +1,4 @@
-import type { Hash } from '@xylabs/hex'
+import { HashZod } from '@xylabs/hex'
 import { asXL1BlockNumber } from '@xyo-network/xl1-protocol'
 import * as z from 'zod'
 
@@ -11,8 +11,6 @@ import { StorageMetaZod } from './Payload.ts'
 
 export const BlockNumberZod = z.number().int().nonnegative()
 export const XL1BlockNumberZod = BlockNumberZod.transform(asXL1BlockNumber)
-export const HexZod = z.string().regex(/^[0-9a-f]+$/)
-export const HashZod = HexZod.transform(v => v as Hash)
 
 const BlockBoundWitnessFieldsZod = z.object({
   block: XL1BlockNumberZod,

package/dist/neutral/provider/client/MemoryXyoClient.d.ts

@@ -1,7 +0,0 @@
-import type { PermissionsProvider, XyoClient, XyoGatewayProvider, XyoPermissions } from '@xyo-network/xl1-protocol-sdk';
-export declare class MemoryXyoClient implements XyoClient {
-    gateways: Readonly<Record<string, XyoGatewayProvider>>;
-    permissions: PermissionsProvider;
-    constructor(gateways: Readonly<Record<string, XyoGatewayProvider>>, permissions: XyoPermissions);
-}
-//# sourceMappingURL=MemoryXyoClient.d.ts.map

package/dist/neutral/provider/client/MemoryXyoClient.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"MemoryXyoClient.d.ts","sourceRoot":"","sources":["../../../../src/provider/client/MemoryXyoClient.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,mBAAmB,EAAE,SAAS,EAAE,kBAAkB,EAClD,cAAc,EACf,MAAM,+BAA+B,CAAA;AAEtC,qBAAa,eAAgB,YAAW,SAAS;IAC/C,QAAQ,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,kBAAkB,CAAC,CAAC,CAAA;IACtD,WAAW,EAAE,mBAAmB,CAAA;gBAEpB,QAAQ,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,kBAAkB,CAAC,CAAC,EAAE,WAAW,EAAE,cAAc;CAIhG"}

package/dist/neutral/provider/client/index.d.ts

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

package/dist/neutral/provider/client/index.d.ts.map

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

package/dist/neutral/provider/client/spec/MemoryXyoClient.spec.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"MemoryXyoClient.spec.d.ts","sourceRoot":"","sources":["../../../../../src/provider/client/spec/MemoryXyoClient.spec.ts"],"names":[],"mappings":""}

package/dist/neutral/provider/gateway/Abstract.d.ts

@@ -1,12 +0,0 @@
-import type { Hash } from '@xylabs/hex';
-import type { Promisable } from '@xylabs/promise';
-import type { Payload } from '@xyo-network/payload-model';
-import type { AllowedBlockPayload, SignedHydratedTransaction } from '@xyo-network/xl1-protocol';
-import type { TransactionOptions, XyoConnection, XyoGatewayProvider, XyoSigner } from '@xyo-network/xl1-protocol-sdk';
-export declare abstract class AbstractXyoGateway implements XyoGatewayProvider {
-    addPayloadsToChain(onChain: AllowedBlockPayload[], offChain: Payload[], options?: TransactionOptions): Promise<[Hash, SignedHydratedTransaction]>;
-    addTransactionToChain(tx: SignedHydratedTransaction): Promise<Hash>;
-    abstract connection(): Promisable<XyoConnection>;
-    abstract signer(): Promisable<XyoSigner>;
-}
-//# sourceMappingURL=Abstract.d.ts.map

package/dist/neutral/provider/gateway/Abstract.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Abstract.d.ts","sourceRoot":"","sources":["../../../../src/provider/gateway/Abstract.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,aAAa,CAAA;AACvC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAA;AAGjD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,4BAA4B,CAAA;AACzD,OAAO,KAAK,EACV,mBAAmB,EACnB,yBAAyB,EAC1B,MAAM,2BAA2B,CAAA;AAClC,OAAO,KAAK,EACV,kBAAkB,EAAE,aAAa,EAAE,kBAAkB,EACrD,SAAS,EACV,MAAM,+BAA+B,CAAA;AAGtC,8BAAsB,kBAAmB,YAAW,kBAAkB;IAC9D,kBAAkB,CAAC,OAAO,EAAE,mBAAmB,EAAE,EAAE,QAAQ,EAAE,OAAO,EAAE,EAAE,OAAO,CAAC,EAAE,kBAAkB,GAAG,OAAO,CAAC,CAAC,IAAI,EAAE,yBAAyB,CAAC,CAAC;IAsBjJ,qBAAqB,CAAC,EAAE,EAAE,yBAAyB,GAAG,OAAO,CAAC,IAAI,CAAC;IAWzE,QAAQ,CAAC,UAAU,IAAI,UAAU,CAAC,aAAa,CAAC;IAChD,QAAQ,CAAC,MAAM,IAAI,UAAU,CAAC,SAAS,CAAC;CACzC"}