@xyo-network/xl1-rpc 1.15.2 → 1.15.4

package/dist/node/types/schema/XyoGatewayRpcSchemas.d.ts

@@ -1,395 +0,0 @@
-import type { Chain } from '@xyo-network/xl1-protocol';
-import * as z from 'zod';
-export declare const ChainConnectionZod: z.ZodObject<{
-    chainId: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodCustom<Chain, Chain>]>>;
-    name: z.ZodString;
-    url: z.ZodString;
-}, z.core.$strip>;
-export type ChainConnection = z.infer<typeof ChainConnectionZod>;
-export declare const XyoGatewayRpcSchemas: {
-    xyoGateway_submitTransaction: {
-        params: {
-            from: z.ZodArray<z.ZodTuple<[z.ZodObject<{
-                schema: z.ZodLiteral<"network.xyo.boundwitness">;
-                addresses: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }>, {
-                    readonly __address: true;
-                }>, string>>>;
-                payload_hashes: z.ZodArray<z.ZodType<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }>, {
-                    readonly __hash: true;
-                }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }>, {
-                    readonly __hash: true;
-                }>, unknown>>>;
-                payload_schemas: z.ZodArray<z.ZodString>;
-                previous_hashes: z.ZodArray<z.ZodNullable<z.ZodType<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }>, {
-                    readonly __hash: true;
-                }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }>, {
-                    readonly __hash: true;
-                }>, unknown>>>>;
-                $destination: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }>, {
-                    readonly __address: true;
-                }>, string>>>;
-                $sourceQuery: z.ZodOptional<z.ZodType<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }>, {
-                    readonly __hash: true;
-                }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }>, {
-                    readonly __hash: true;
-                }>, unknown>>>;
-                $signatures: z.ZodArray<z.ZodUnion<readonly [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>>, z.ZodNull]>>;
-                _hash: z.ZodOptional<z.ZodPipe<z.ZodType<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }>, {
-                    readonly __hash: true;
-                }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }>, {
-                    readonly __hash: true;
-                }>, unknown>>, z.ZodTransform<string, import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }>, {
-                    readonly __hash: true;
-                }>>>>;
-                _dataHash: z.ZodOptional<z.ZodPipe<z.ZodType<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }>, {
-                    readonly __hash: true;
-                }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }>, {
-                    readonly __hash: true;
-                }>, unknown>>, z.ZodTransform<string, import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }>, {
-                    readonly __hash: true;
-                }>>>>;
-                _sequence: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodString]>>;
-                nbf: z.ZodNumber;
-                exp: z.ZodNumber;
-                fees: 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>>;
-                }, z.core.$strip>;
-                chain: z.ZodPipe<z.ZodString, z.ZodTransform<Chain, string>>;
-                from: z.ZodPipe<z.ZodString, z.ZodTransform<Chain, string>>;
-                script: z.ZodOptional<z.ZodArray<z.ZodString>>;
-            }, z.core.$strip>, z.ZodArray<z.ZodObject<{
-                schema: z.ZodString;
-            }, z.core.$catchall<z.ZodAny>>>], null>>;
-            to: z.ZodArray<z.ZodTuple<[z.ZodObject<{
-                schema: z.ZodLiteral<"network.xyo.boundwitness">;
-                addresses: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }>, {
-                    readonly __address: true;
-                }>, string>>>;
-                payload_hashes: z.ZodArray<z.ZodType<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }>, {
-                    readonly __hash: true;
-                }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }>, {
-                    readonly __hash: true;
-                }>, unknown>>>;
-                payload_schemas: z.ZodArray<z.ZodString>;
-                previous_hashes: z.ZodArray<z.ZodNullable<z.ZodType<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }>, {
-                    readonly __hash: true;
-                }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }>, {
-                    readonly __hash: true;
-                }>, unknown>>>>;
-                $destination: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }>, {
-                    readonly __address: true;
-                }>, string>>>;
-                $sourceQuery: z.ZodOptional<z.ZodType<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }>, {
-                    readonly __hash: true;
-                }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }>, {
-                    readonly __hash: true;
-                }>, unknown>>>;
-                $signatures: z.ZodArray<z.ZodUnion<readonly [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>>, z.ZodNull]>>;
-                _hash: z.ZodOptional<z.ZodPipe<z.ZodType<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }>, {
-                    readonly __hash: true;
-                }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }>, {
-                    readonly __hash: true;
-                }>, unknown>>, z.ZodTransform<string, import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }>, {
-                    readonly __hash: true;
-                }>>>>;
-                _dataHash: z.ZodOptional<z.ZodPipe<z.ZodType<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }>, {
-                    readonly __hash: true;
-                }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }>, {
-                    readonly __hash: true;
-                }>, unknown>>, z.ZodTransform<string, import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }>, {
-                    readonly __hash: true;
-                }>>>>;
-                _sequence: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodString]>>;
-                nbf: z.ZodNumber;
-                exp: z.ZodNumber;
-                fees: 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>>;
-                }, z.core.$strip>;
-                chain: z.ZodPipe<z.ZodString, z.ZodTransform<Chain, string>>;
-                from: z.ZodPipe<z.ZodString, z.ZodTransform<Chain, string>>;
-                script: z.ZodOptional<z.ZodArray<z.ZodString>>;
-            }, z.core.$strip>, z.ZodArray<z.ZodObject<{
-                schema: z.ZodString;
-            }, z.core.$catchall<z.ZodAny>>>], null>>;
-        };
-        result: {
-            from: z.ZodObject<{
-                schema: z.ZodLiteral<"network.xyo.boundwitness">;
-                addresses: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }>, {
-                    readonly __address: true;
-                }>, string>>>;
-                payload_hashes: z.ZodArray<z.ZodType<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }>, {
-                    readonly __hash: true;
-                }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }>, {
-                    readonly __hash: true;
-                }>, unknown>>>;
-                payload_schemas: z.ZodArray<z.ZodString>;
-                previous_hashes: z.ZodArray<z.ZodNullable<z.ZodType<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }>, {
-                    readonly __hash: true;
-                }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }>, {
-                    readonly __hash: true;
-                }>, unknown>>>>;
-                $destination: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }>, {
-                    readonly __address: true;
-                }>, string>>>;
-                $sourceQuery: z.ZodOptional<z.ZodType<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }>, {
-                    readonly __hash: true;
-                }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }>, {
-                    readonly __hash: true;
-                }>, unknown>>>;
-                $signatures: z.ZodArray<z.ZodUnion<readonly [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>>, z.ZodNull]>>;
-                _hash: z.ZodOptional<z.ZodPipe<z.ZodType<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }>, {
-                    readonly __hash: true;
-                }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }>, {
-                    readonly __hash: true;
-                }>, unknown>>, z.ZodTransform<string, import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }>, {
-                    readonly __hash: true;
-                }>>>>;
-                _dataHash: z.ZodOptional<z.ZodPipe<z.ZodType<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }>, {
-                    readonly __hash: true;
-                }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }>, {
-                    readonly __hash: true;
-                }>, unknown>>, z.ZodTransform<string, import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }>, {
-                    readonly __hash: true;
-                }>>>>;
-                _sequence: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodString]>>;
-                block: z.ZodNumber;
-                chain: z.ZodPipe<z.ZodString, z.ZodTransform<Chain, string>>;
-                previous: z.ZodNullable<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>>>;
-                protocol: z.ZodOptional<z.ZodNumber>;
-                step_hashes: z.ZodOptional<z.ZodArray<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>>>>;
-                $epoch: z.ZodNumber;
-            }, z.core.$strip>;
-            to: z.ZodObject<{
-                schema: z.ZodLiteral<"network.xyo.boundwitness">;
-                addresses: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }>, {
-                    readonly __address: true;
-                }>, string>>>;
-                payload_hashes: z.ZodArray<z.ZodType<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }>, {
-                    readonly __hash: true;
-                }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }>, {
-                    readonly __hash: true;
-                }>, unknown>>>;
-                payload_schemas: z.ZodArray<z.ZodString>;
-                previous_hashes: z.ZodArray<z.ZodNullable<z.ZodType<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }>, {
-                    readonly __hash: true;
-                }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }>, {
-                    readonly __hash: true;
-                }>, unknown>>>>;
-                $destination: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }>, {
-                    readonly __address: true;
-                }>, string>>>;
-                $sourceQuery: z.ZodOptional<z.ZodType<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }>, {
-                    readonly __hash: true;
-                }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }>, {
-                    readonly __hash: true;
-                }>, unknown>>>;
-                $signatures: z.ZodArray<z.ZodUnion<readonly [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>>, z.ZodNull]>>;
-                _hash: z.ZodOptional<z.ZodPipe<z.ZodType<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }>, {
-                    readonly __hash: true;
-                }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }>, {
-                    readonly __hash: true;
-                }>, unknown>>, z.ZodTransform<string, import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }>, {
-                    readonly __hash: true;
-                }>>>>;
-                _dataHash: z.ZodOptional<z.ZodPipe<z.ZodType<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }>, {
-                    readonly __hash: true;
-                }>, unknown, z.core.$ZodTypeInternals<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }>, {
-                    readonly __hash: true;
-                }>, unknown>>, z.ZodTransform<string, import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                    readonly __hex: true;
-                }>, {
-                    readonly __hash: true;
-                }>>>>;
-                _sequence: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodString]>>;
-                block: z.ZodNumber;
-                chain: z.ZodPipe<z.ZodString, z.ZodTransform<Chain, string>>;
-                previous: z.ZodNullable<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>>>;
-                protocol: z.ZodOptional<z.ZodNumber>;
-                step_hashes: z.ZodOptional<z.ZodArray<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>>>>;
-                $epoch: z.ZodNumber;
-            }, z.core.$strip>;
-        };
-    };
-};
-//# sourceMappingURL=XyoGatewayRpcSchemas.d.ts.map

package/dist/node/types/schema/XyoGatewayRpcSchemas.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"XyoGatewayRpcSchemas.d.ts","sourceRoot":"","sources":["../../../../src/types/schema/XyoGatewayRpcSchemas.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,2BAA2B,CAAA;AACtD,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAMxB,eAAO,MAAM,kBAAkB;;;;iBAI7B,CAAA;AAEF,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA;AAEhE,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6EgB,CAAA"}

package/src/provider/client/PermissionsStore/MemoryPermissionsStore.ts

@@ -1,33 +0,0 @@
-import type { Promisable } from '@xylabs/promise'
-import type { InvokerPermission, Permission } from '@xyo-network/xl1-protocol'
-
-import type { PermissionsStore } from './PermissionsStore.ts'
-
-export class MemoryPermissionsStore implements PermissionsStore {
-  private readonly _store: Map<string, InvokerPermission> = new Map()
-
-  getPermissions(): Promisable<InvokerPermission[]> {
-    return [...this._store.values()]
-  }
-
-  requestPermissions(permissions: Permission[]): Promisable<boolean> {
-    const now = Date.now()
-    for (const perm of permissions) {
-      const key = this.getKey(perm)
-      this._store.set(key, { ...perm, date: now })
-    }
-    return true
-  }
-
-  revokePermissions(permissions: Permission[]): Promisable<boolean> {
-    for (const perm of permissions) {
-      const key = this.getKey(perm)
-      this._store.delete(key)
-    }
-    return true
-  }
-
-  private getKey(permission: Permission): string {
-    return `${permission.invoker}::${permission.capability}`
-  }
-}

package/src/provider/client/PermissionsStore/PermissionsStore.ts

@@ -1,8 +0,0 @@
-import type { Promisable } from '@xylabs/promise'
-import type { InvokerPermission, Permission } from '@xyo-network/xl1-protocol'
-
-export interface PermissionsStore {
-  getPermissions(): Promisable<InvokerPermission[]>
-  requestPermissions(permissions: Permission[]): Promisable<boolean>
-  revokePermissions(permissions: Permission[]): Promisable<boolean>
-}

package/src/provider/client/PermissionsStore/getPermissionsStoreFromTransport.ts

@@ -1,12 +0,0 @@
-import { type RpcTransport } from '../../../transport/index.ts'
-import type { XyoGatewayRpcSchemas } from '../../../types/index.ts'
-import type { PermissionsStore } from './PermissionsStore.ts'
-
-export const getPermissionsStoreFromTransport = (_transport: RpcTransport<typeof XyoGatewayRpcSchemas>): PermissionsStore => {
-  throw new Error('Not implemented')
-  // return {
-  //   getPermissions: () => transport.sendRequest('xyoGateway_getPermissions'),
-  //   requestPermissions: (permissions: Permission[]) => transport.sendRequest('xyoGateway_requestPermissions', permissions),
-  //   revokePermissions: (permissions: Permission[]) => transport.sendRequest('xyoGateway_revokePermissions', permissions),
-  // }
-}

package/src/provider/client/PermissionsStore/index.ts

@@ -1,3 +0,0 @@
-export * from './getPermissionsStoreFromTransport.ts'
-export * from './MemoryPermissionsStore.ts'
-export * from './PermissionsStore.ts'

package/src/provider/client/PermissionsStore/spec/MemoryPermissionsStore.spec.ts

@@ -1,78 +0,0 @@
-import type { Permission } from '@xyo-network/xl1-protocol'
-import {
-  beforeEach, describe, expect, it,
-} from 'vitest'
-
-import { MemoryPermissionsStore } from '../MemoryPermissionsStore.ts'
-
-describe('MemoryPermissionsStore', () => {
-  const invoker = 'https://example.com'
-  const capability = 'xyoViewer_chainId'
-  let store: MemoryPermissionsStore
-  const basePermission: Permission = { capability, invoker }
-
-  beforeEach(() => {
-    store = new MemoryPermissionsStore()
-  })
-
-  it('returns an empty list initially', async () => {
-    const permissions = await store.getPermissions()
-    expect(permissions).toEqual([])
-  })
-
-  it('adds and retrieves a permission', async () => {
-    const result = await store.requestPermissions([basePermission])
-    expect(result).toBe(true)
-
-    const permissions = await store.getPermissions()
-    expect(permissions.length).toBe(1)
-    expect(permissions[0].capability).toBe(basePermission.capability)
-    expect(permissions[0].invoker).toBe(basePermission.invoker)
-    expect(typeof permissions[0].date).toBe('number')
-  })
-
-  it('replaces an existing permission with the same key', async () => {
-    const original = { ...basePermission }
-    const updated = { ...basePermission }
-
-    await store.requestPermissions([original])
-    const originalDate = (await store.getPermissions())[0].date
-
-    await new Promise(r => setTimeout(r, 5)) // ensure timestamp difference
-    await store.requestPermissions([updated])
-    const updatedDate = (await store.getPermissions())[0].date
-
-    expect(updatedDate).toBeGreaterThan(originalDate!)
-  })
-
-  it('revokes a previously granted permission', async () => {
-    await store.requestPermissions([basePermission])
-    expect((await store.getPermissions()).length).toBe(1)
-
-    const result = await store.revokePermissions([basePermission])
-    expect(result).toBe(true)
-
-    const permissions = await store.getPermissions()
-    expect(permissions).toEqual([])
-  })
-
-  it('revoking a non-existent permission does nothing and returns true', async () => {
-    const result = await store.revokePermissions([basePermission])
-    expect(result).toBe(true)
-    expect(await store.getPermissions()).toEqual([])
-  })
-
-  it('can handle multiple permissions from different invokers', async () => {
-    const perms: Permission[] = [
-      { invoker: 'https://a.com', capability: 'xyo_1' },
-      { invoker: 'https://b.com', capability: 'xyo_2' },
-      { invoker: 'https://a.com', capability: 'xyo_3' },
-    ]
-
-    await store.requestPermissions(perms)
-    const results = await store.getPermissions()
-
-    expect(results.length).toBe(3)
-    expect(results.map(p => p.capability).toSorted((a, b) => a.localeCompare(b))).toEqual(['xyo_1', 'xyo_2', 'xyo_3'])
-  })
-})

package/src/transport/post-message/LegacyPostMessageRpcTransport.ts

@@ -1,120 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import type { JsonRpcRequest } from '@metamask/utils'
-import {
-  isJsonRpcError,
-  isJsonRpcSuccess,
-} from '@metamask/utils'
-import { isDefined } from '@xylabs/typeof'
-import { v4 } from 'uuid'
-import type * as z from 'zod'
-
-import type { RpcSchemaMap, XyoGatewayRpcMethodName } from '../../types/index.ts'
-import { jsonrpc, XyoGatewayRpcSchemas } from '../../types/index.ts'
-import type { RpcTransport } from '../RpcTransport.ts'
-// eslint-disable-next-line sonarjs/deprecation
-import { isRpcError } from './helpers.ts'
-import { resolvedEvent } from './resolveData.ts'
-
-const isValidBaseRpcEvent = (data: any) => {
-  return !!(data && typeof data === 'object'
-    && 'jsonrpc' in data && data.jsonrpc === '2.0'
-    && 'method' in data && typeof data.method === 'string'
-    && 'id' in data && typeof data.id === 'string')
-}
-
-const isRpcResponse = (data: any, targetId: string) => {
-  return isValidBaseRpcEvent(data) && (isDefined(targetId) ? data.id === targetId : true) && 'result' in data && Array.isArray(data.result)
-}
-
-/** @deprecated - now part of a client gateway */
-export class LegacyPostMessageRpcTransport implements RpcTransport<RpcSchemaMap<XyoGatewayRpcMethodName>> {
-  protected readonly destination?: string
-  protected readonly schemas: RpcSchemaMap<XyoGatewayRpcMethodName>
-  protected readonly sessionId?: string
-
-  constructor(defaultDestination?: string, sessionId?: string) {
-    this.schemas = XyoGatewayRpcSchemas
-    this.destination = defaultDestination
-    this.sessionId = sessionId
-  }
-
-  async sendRequest<
-    TMethod extends keyof RpcSchemaMap<XyoGatewayRpcMethodName>,
-  >(
-    method: TMethod,
-    params?: z.input<RpcSchemaMap<XyoGatewayRpcMethodName>[TMethod]['params']['to']>,
-  ): Promise<z.output<RpcSchemaMap<XyoGatewayRpcMethodName>[TMethod]['result']['from']>> {
-    const id = v4()
-    return await this.callRpc(this.schemas, method, id, params)
-  }
-
-  private async callRpc<
-    TSchemas extends RpcSchemaMap,
-    TMethod extends keyof TSchemas,
-  >(
-    schemas: TSchemas,
-    method: TMethod,
-    id: string,
-    params?: z.input<TSchemas[TMethod]['params']['to']>,
-  ): Promise<z.output<TSchemas[TMethod]['result']['from']>> {
-    const body: JsonRpcRequest = {
-      jsonrpc,
-      id,
-      method: method as string,
-    }
-
-    body.params = ((isDefined(params) && isDefined(schemas[method])) ? schemas[method].params.to.parse(params) : params) as JsonRpcRequest
-
-    return await new Promise((resolve, reject) => {
-      const id = body.id
-
-      const handler = (event: MessageEvent) => {
-        if (event.origin !== globalThis.window.origin) return
-        if (!isRpcResponse(event.data, id as string)) return
-        const data = resolvedEvent(event, id as string)
-        if (data === false) return
-
-        globalThis.removeEventListener('message', handler)
-
-        if (data.legacyEventData) {
-          // Handle legacy event data
-          // eslint-disable-next-line sonarjs/deprecation
-          if (data.legacyEventData.result.some(isRpcError)) {
-            reject(data.legacyEventData.result[0])
-          } else {
-            resolve(data.legacyEventData.result[0])
-          }
-          return
-        }
-
-        if (data.eventData) {
-          // Handle new event data
-          if (isJsonRpcError(data.eventData)) {
-            reject(data.eventData)
-            return
-          }
-          if (isJsonRpcSuccess(data.eventData)) {
-            resolve(data.eventData as z.infer<TSchemas[TMethod]['result']['from']>)
-            return
-          }
-          reject(new Error('Unexpected response format'))
-        }
-      }
-
-      globalThis.addEventListener('message', handler)
-
-      globalThis.postMessage(
-        {
-          data: body,
-          destination: this.destination,
-          sessionId: this.sessionId,
-        },
-        globalThis.location.origin,
-      )
-    })
-  }
-}
-
-/** @deprecated - use LegacyPostMessageRpcTransport but rely on wallet release > 1.17.1 to handle the postMessage flow */
-// eslint-disable-next-line sonarjs/deprecation
-export const PostMessageRpcTransport = LegacyPostMessageRpcTransport