@xyo-network/xl1-rpc 1.15.27 → 1.16.0

package/dist/neutral/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/neutral/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/neutral/types/schema/common/spec/UnsignedHydratedTransactionSchema.spec copy.d.ts

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

package/dist/neutral/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/dist/node/engine/index-node.d.ts

@@ -1,4 +0,0 @@
-export * from './index.ts';
-export * from './rpcEngineFromConnection.ts';
-export * from './rpcMethodHandlersFromConnection.ts';
-//# sourceMappingURL=index-node.d.ts.map

package/dist/node/engine/index-node.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index-node.d.ts","sourceRoot":"","sources":["../../../src/engine/index-node.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAA;AAC1B,cAAc,8BAA8B,CAAA;AAC5C,cAAc,sCAAsC,CAAA"}

package/dist/node/engine/rpcEngineFromConnection.d.ts

@@ -1,4 +0,0 @@
-import { JsonRpcEngine } from '@metamask/json-rpc-engine';
-import type { XyoConnection } from '@xyo-network/xl1-protocol';
-export declare const rpcEngineFromConnection: (connection: XyoConnection) => JsonRpcEngine;
-//# sourceMappingURL=rpcEngineFromConnection.d.ts.map

package/dist/node/engine/rpcEngineFromConnection.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"rpcEngineFromConnection.d.ts","sourceRoot":"","sources":["../../../src/engine/rpcEngineFromConnection.ts"],"names":[],"mappings":"AAAA,OAAO,EAAyB,aAAa,EAAE,MAAM,2BAA2B,CAAA;AAEhF,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAA;AAQ9D,eAAO,MAAM,uBAAuB,GAAI,YAAY,aAAa,kBA8ChE,CAAA"}

package/dist/node/provider/connection/spec/XyoConnection.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=XyoConnection.d.ts.map

package/dist/node/provider/connection/spec/XyoConnection.d.ts.map

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

package/dist/node/transport/post-message/SessionEnvelope.d.ts

@@ -1,11 +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 declare const buildSessionMessageRequest: <T extends JsonRpcRequest>(data: T, destination?: string) => SessionMessageEnvelope<T>;
-//# sourceMappingURL=SessionEnvelope.d.ts.map

package/dist/node/transport/post-message/SessionEnvelope.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"SessionEnvelope.d.ts","sourceRoot":"","sources":["../../../../src/transport/post-message/SessionEnvelope.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAA;AACrD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAE/C,MAAM,WAAW,sBAAsB,CAAC,CAAC,SAAS,SAAS;IACzD,IAAI,EAAE,CAAC,CAAA;IACP,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,SAAS,EAAE,MAAM,CAAA;CAClB;AAED,4EAA4E;AAC5E,gEAAgE;AAChE,eAAO,MAAM,0BAA0B,GAAI,CAAC,SAAS,cAAc,EAAE,MAAM,CAAC,EAAE,cAAc,MAAM,8BAQjG,CAAA"}

package/dist/node/transport/post-message/helpers.d.ts

@@ -1,14 +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 */
-export declare const isRpcError: (data: any) => data is RpcError;
-//# sourceMappingURL=helpers.d.ts.map

package/dist/node/transport/post-message/helpers.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../../../src/transport/post-message/helpers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAA;AACrD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAA;AAEhD,oEAAoE;AACpE,MAAM,MAAM,oBAAoB,GAAG,cAAc,GAAG;IAClD,EAAE,EAAE,MAAM,CAAA;CACX,CAAA;AAED,oEAAoE;AACpE,MAAM,WAAW,QAAS,SAAQ,UAAU;IAC1C,KAAK,EAAE,OAAO,CAAA;IACd,OAAO,EAAE,MAAM,CAAA;CAChB;AAED,oEAAoE;AAEpE,eAAO,MAAM,UAAU,GAAI,MAAM,GAAG,KAAG,IAAI,IAAI,QAO9C,CAAA"}

package/dist/node/transport/post-message/index.d.ts

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

package/dist/node/transport/post-message/index.d.ts.map

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

package/dist/node/transport/post-message/resolveData.d.ts

@@ -1,13 +0,0 @@
-/**
- * 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;
-};
-export declare const resolvedEvent: (event: MessageEvent, targetId: string) => false | ResolvedEventData;
-export {};
-//# sourceMappingURL=resolveData.d.ts.map

package/dist/node/transport/post-message/resolveData.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"resolveData.d.ts","sourceRoot":"","sources":["../../../../src/transport/post-message/resolveData.ts"],"names":[],"mappings":"AAEA;;;;;GAKG;AAEH,KAAK,iBAAiB,GAAG;IACvB,SAAS,CAAC,EAAE,GAAG,CAAA;IACf,eAAe,CAAC,EAAE,GAAG,CAAA;CACtB,CAAA;AAcD,eAAO,MAAM,aAAa,GAAI,OAAO,YAAY,EAAE,UAAU,MAAM,KAAG,KAAK,GAAG,iBAG7E,CAAA"}