@xyo-network/xl1-rpc 1.15.27 → 1.16.0

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

@@ -1,298 +0,0 @@
-import * as z from 'zod';
-export declare const XyoProviderRpcSchemas: {
-    xyoProvider_send: {
-        params: {
-            to: z.ZodTuple<[z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                readonly __hex: true;
-            }>, {
-                readonly __address: true;
-            }>, string>>, z.ZodArray<z.ZodObject<{
-                schema: z.ZodString;
-            }, z.core.$catchall<z.ZodAny>>>, z.ZodArray<z.ZodObject<{
-                schema: z.ZodString;
-            }, z.core.$catchall<z.ZodAny>>>, z.ZodNumber, z.ZodNumber, z.ZodPipe<z.ZodObject<{
-                base: z.ZodBigInt;
-                gasLimit: z.ZodBigInt;
-                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: bigint;
-                gasLimit: bigint;
-                gasPrice: bigint;
-                priority: bigint;
-            }>>, 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>>>], null>;
-            from: z.ZodTuple<[z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
-                readonly __hex: true;
-            }>, {
-                readonly __address: true;
-            }>, string>>, z.ZodArray<z.ZodObject<{
-                schema: z.ZodString;
-            }, z.core.$catchall<z.ZodAny>>>, z.ZodArray<z.ZodObject<{
-                schema: z.ZodString;
-            }, z.core.$catchall<z.ZodAny>>>, z.ZodNumber, z.ZodNumber, 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>>;
-            }, 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;
-                }>;
-            }>>, 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>>>], null>;
-        };
-        result: {
-            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]>>;
-                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<import("@xyo-network/xl1-protocol").ChainId, string>>;
-                from: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xyo-network/xl1-protocol").ChainId, string>>;
-                script: z.ZodOptional<z.ZodOptional<z.ZodArray<z.ZodString>>>;
-            }, z.core.$strip>;
-            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]>>;
-                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<import("@xyo-network/xl1-protocol").ChainId, string>>;
-                from: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xyo-network/xl1-protocol").ChainId, string>>;
-                script: z.ZodOptional<z.ZodOptional<z.ZodArray<z.ZodString>>>;
-            }, z.core.$strip>;
-        };
-    };
-};
-//# sourceMappingURL=XyoProviderRpcSchemas.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"XyoProviderRpcSchemas.d.ts","sourceRoot":"","sources":["../../../../src/types/schema/XyoProviderRpcSchemas.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AASxB,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2BgB,CAAA"}

package/dist/node/types/schema/common/spec/UnsignedHydratedTransactionSchema.spec copy.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=UnsignedHydratedTransactionSchema.spec%20copy.d.ts.map

package/dist/node/types/schema/common/spec/UnsignedHydratedTransactionSchema.spec copy.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"UnsignedHydratedTransactionSchema.spec copy.d.ts","sourceRoot":"","sources":["../../../../../../src/types/schema/common/spec/UnsignedHydratedTransactionSchema.spec copy.ts"],"names":[],"mappings":""}

package/src/engine/index-node.ts

@@ -1,3 +0,0 @@
-export * from './index.ts'
-export * from './rpcEngineFromConnection.ts'
-export * from './rpcMethodHandlersFromConnection.ts'

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

@@ -1,26 +0,0 @@
-import { toAddress } from '@xylabs/hex'
-import { Account } from '@xyo-network/account'
-import type { XyoConnection } from '@xyo-network/xl1-protocol'
-import {
-  beforeAll, describe, expect, it,
-} from 'vitest'
-
-import { MemoryXyoRunner } from '../../runner/index.ts'
-import { MemoryXyoSigner } from '../../signer/index.ts'
-import { XyoBaseConnection } from '../XyoBaseConnection.ts'
-
-describe('RpcEngine - XyoProvider', () => {
-  const chain = toAddress('2AAE728aFd1777b79c34D79c4523797F9D9965b0')
-  let sut: XyoConnection
-  beforeAll(async () => {
-    const account = await Account.random()
-    const runner = new MemoryXyoRunner()
-    const signer = new MemoryXyoSigner(account)
-    sut = new XyoBaseConnection({ runner, signer })
-  })
-  it('should submit transaction', async () => {
-    // eslint-disable-next-line sonarjs/deprecation
-    const result = await sut.send?.([], [], chain, 0, Number.MAX_VALUE)
-    expect(result).toBeDefined()
-  })
-})

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

@@ -1,20 +0,0 @@
-import type { JsonRpcRequest } from '@metamask/utils'
-import type { JsonValue } from '@xylabs/object'
-
-export interface SessionMessageEnvelope<T extends JsonValue> {
-  data: T
-  destination?: string
-  sessionId: string
-}
-
-/** Only intended for web pages where the xyo global object was injected  */
-/** @deprecated - this is now handled in the wallet extension */
-export const buildSessionMessageRequest = <T extends JsonRpcRequest>(data: T, destination?: string) => {
-  const request: SessionMessageEnvelope<T> = {
-    data,
-    destination,
-    sessionId: globalThis.xyo.walletExtensionId() ?? '',
-  }
-
-  return request
-}

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

@@ -1,24 +0,0 @@
-import type { JsonRpcRequest } from '@metamask/utils'
-import type { JsonObject } from '@xylabs/object'
-
-/** @deprecated - no longer part of the public rpc implementation */
-export type JsonRpcRequestWithId = JsonRpcRequest & {
-  id: string
-}
-
-/** @deprecated - no longer part of the public rpc implementation */
-export interface RpcError extends JsonObject {
-  error: boolean
-  message: string
-}
-
-/** @deprecated - no longer part of the public rpc implementation */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any, sonarjs/deprecation
-export const isRpcError = (data: any): data is RpcError => {
-  return (
-    data
-    && typeof data === 'object'
-    && 'error' in data
-    && data.error
-  )
-}

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

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

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

@@ -1,30 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-
-/**
- * NOTE: This file is to help resolve the data from a postMessage event in the transport
- * layer.  Older implementations require the id to be at the top level, while newer
- * implementations nest the id inside a data object.  Once the wallet extension is updated
- * to always use the nested structure, this file can be removed.
- */
-
-type ResolvedEventData = {
-  eventData?: any
-  legacyEventData?: any
-}
-
-// If the id is present in the eventData and matches the targetId, return the eventData
-// and mark it as legacyEventData since newer implementations nest the id inside a data object
-const hasMatchingId = (eventData: any, targetId: string): false | ResolvedEventData => {
-  return eventData?.id === targetId ? { legacyEventData: eventData } : false
-}
-
-// If the id is present in the data object of the eventData and matches the targetId,
-// return the eventData as eventData so its clear that this is a newer implementation
-const hasMatchingNestedId = (eventData: any, targetId: string): false | ResolvedEventData => {
-  return eventData?.data?.id === targetId ? { eventData: eventData.data } : false
-}
-
-export const resolvedEvent = (event: MessageEvent, targetId: string): false | ResolvedEventData => {
-  // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
-  return hasMatchingId(event.data, targetId) || hasMatchingNestedId(event.data, targetId)
-}

package/src/types/global.d.ts

@@ -1,15 +0,0 @@
-export interface XyoGlobal {
-  _debug: () => void
-  provider?: XyoProvider
-  walletExtensionId: () => string
-}
-
-export declare global {
-  interface Window {
-    xyo: XyoGlobal
-  }
-
-  var xyo: XyoGlobal
-  /** @deprecated - use globalThis.xyo.walletExtensionId() instead */
-  var xyoWalletExtensionId: string
-}

package/src/types/schema/XyoProviderRpcSchemas.ts

@@ -1,37 +0,0 @@
-import * as z from 'zod'
-
-import type { XyoProviderRpcMethodName } from '../XyoProviderRpc.ts'
-import {
-  AddressZod, PayloadZod, SignedTransactionBoundWitnessZod, TransactionFeesBigIntToJsonZod,
-  TransactionFeesJsonToBigIntZod,
-} from './common/index.ts'
-import type { RpcSchemaMap } from './RpcSchemaMap.ts'
-
-export const XyoProviderRpcSchemas = {
-  xyoProvider_send: {
-    params: {
-      to: z.tuple([
-        AddressZod,
-        z.array(PayloadZod),
-        z.array(PayloadZod),
-        z.number().nonnegative(),
-        z.number().nonnegative(),
-        TransactionFeesBigIntToJsonZod,
-        AddressZod.optional(),
-      ]),
-      from: z.tuple([
-        AddressZod,
-        z.array(PayloadZod),
-        z.array(PayloadZod),
-        z.number().nonnegative(),
-        z.number().nonnegative(),
-        TransactionFeesJsonToBigIntZod,
-        AddressZod.optional(),
-      ]),
-    },
-    result: {
-      to: SignedTransactionBoundWitnessZod,
-      from: SignedTransactionBoundWitnessZod,
-    },
-  },
-} satisfies RpcSchemaMap<XyoProviderRpcMethodName>